Ejemplo n.º 1
0
 vector<string> wordBreak(string s, unordered_set<string> &dict) {
     string result;
     vector<string> solutions;
     int len = s.size();
     vector<bool> possible(len + 1, true);
     GetAllSolution(0, s, dict, len, result, solutions, possible);
     return solutions;
 }
Ejemplo n.º 2
0
 vector<string> wordBreak(string s, unordered_set<string>& wordDict) 
 {
     vector<string> sentences;
     vector<string> sol;
     vector<int> possible(s.length()+1, true); 
     findWordBreak(s, wordDict, 0, sol, sentences, possible);
     return sentences;
 }
Ejemplo n.º 3
0
void movement(roomGrid *room_grid, progress *puzzle, char *instructions_list[NUM_INSTRUCTIONS], Chicken *hen)
{
    SDL_Delay(20);
    SDL_Event event;  // call SDL_Event
        if (SDL_PollEvent(&event))  // If there is an event
        {
        // HandleEvent(event, rcSrc, rcSprite); //Run the HandleEvent function
        switch (event.type) 
        {
            case SDL_QUIT:
                room_grid -> gamerunning = false;
                break;
            case SDL_KEYDOWN:
            switch (event.key.keysym.sym)
            {
                case SDLK_q:
                    room_grid -> gamerunning = false;
                    break;
                case SDLK_LEFT:
                    room_grid -> direction = left;
                    (!((room_grid -> rcSprite.x) % TILE_SIZE)) ? possible(room_grid, puzzle): move(room_grid, puzzle);
                    break;
                case SDLK_RIGHT:
                    room_grid -> direction = right;
                    (!((room_grid -> rcSprite.x) % TILE_SIZE)) ? possible(room_grid, puzzle): move(room_grid, puzzle);
                    break;
                case SDLK_UP:
                    room_grid -> direction = up;
                    (!((room_grid -> rcSprite.y) % TILE_SIZE)) ? possible(room_grid, puzzle): move(room_grid, puzzle);
                    break;
                case SDLK_DOWN:
                    room_grid -> direction = down;
                    (!((room_grid -> rcSprite.y) % TILE_SIZE)) ? possible(room_grid, puzzle): move(room_grid, puzzle);
                    break;
                case SDLK_SPACE:
                    interactProbe(room_grid, puzzle, instructions_list, hen);
                    break;
                case SDLK_9:
                    sound_on_off(room_grid);
                    break;
            }
            break;
        }
    }
}
Ejemplo n.º 4
0
std::vector<std::string> wordBreak2(std::string s, std::unordered_set<std::string>& dict) 
{
	std::string result;
	std::vector<std::string> solutions;
	int len = s.size();
	std::vector<bool> possible(len, true); //possible[i]为true表示[i, n - 1]有解
	GetAllSolution(0, s, dict, len, result, solutions, possible);
	return solutions;
}
Ejemplo n.º 5
0
bool judge()
{
    for(int i=0;i<n;++i)
    {
        if(possible(i))
        {
            return true;
        }
    }
    return false;
}
Ejemplo n.º 6
0
    vector<string> wordBreak(const string& s, const unordered_set<string>& wordDict) {
        vector<string> result;
        if (wordDict.empty() || s.empty()) {
            return std::move(result);
        }

        vector<bool> possible(s.size() + 1, true);
        vector<string> stack;
        this->recursiveSolve(result, stack, possible, s.cbegin(), s, wordDict);

        return std::move(result);
    }
Ejemplo n.º 7
0
Archivo: 1003.c Proyecto: larryzju/zoj
void possible( int M, int m, int cnt )
{
    if ( m == 1 && M == 1 ) 
    {
        large_valid = 1;
    }
    else 
    {
        if ( m == 1 )
        {
            small_valid = 1;
        }

        while( cnt > 0 )
        {
            if ( M % cnt == 0 ) possible( M/cnt, m, cnt-1 );
            if ( m % cnt == 0 ) possible( M, m/cnt, cnt-1 );
            cnt --;
        }
    }
}
 int smallestDistancePair(vector<int>& nums, int k) {
     sort(nums.begin(), nums.end());
     int left = 0, right = nums.back() - nums.front() + 1;
     while (left < right) {
         const auto mid = left + (right - left) / 2;
         if (possible(mid, nums, k)) {
             right = mid;
         } else {
             left = mid + 1;
         }
     }
     return left;
 }
Ejemplo n.º 9
0
int main(void){
	while(scanf("%d%d", &n, &v) == 2){
		int min_cap = 0, u, v, w;
		FOR(i, n) scanf("%d", z + i), min_cap = max(min_cap, z[i]);
		for(u = min_cap, v = MAXC; u < v; ){
			w = (u + v) >> 1;
			if(!possible(w)) u = w + 1;
			else v = w;
		}
		printf("%d\n", u);
	}
	return 0;
}
 double minmaxGasDist(vector<int>& stations, int K) {
     double left = 0.0;
     double right = 1e8;
     while (right - left > 1e-6) {
         const auto mid = left + (right - left) / 2.0;
         if (possible(stations, K, mid)) {
             right = mid;
         } else {
             left = mid;
         }
     }
     return left;
 }
Ejemplo n.º 11
0
 bool wordBreak(string s, unordered_set<string> &dict) {
     string s2 = '#' + s;
     int len = s2.size();
     vector<bool> possible(len, 0);
     possible[0] = true;
     for(int i =1; i< len; ++i) {
         for(int k=0; k<i; ++k) {
             possible[i] = possible[k] &&
             dict.find(s2.substr(k+1, i-k)) != dict.end();
             if(possible[i]) break;
         }
     }
     return possible[len-1];
 }
Ejemplo n.º 12
0
void search(char *begin) {
#ifdef _DEBUG
    printf("# Search: %s\tLongest: %s\n",begin,longestWord);
#endif
    for(int i=0; i<dictionarySize; i++) {
        if(visited[i])
            continue;
        if(!possible(begin,dictionary[i]))
            continue;
        if(strlen(longestWord)<strlen(dictionary[i]))
            longestWord=dictionary[i];
        visited[i]=true;
        search(dictionary[i]);
    }
}
Ejemplo n.º 13
0
int main(){

    int a, b, c; scanf("%d %d %d\n", &a, &b, &c);
    std::vector<bool> possible(c + 1, 0);
    possible[0] = 1;
    for(int p = 0; p <= c; p++){
        if(!possible[p]){continue;}
        if(p + a <= c){possible[p + a] = 1;}
        if(p + b <= c){possible[p + b] = 1;}
    }

    puts(possible[c] ? "Yes" : "No");

    return 0;
}
Ejemplo n.º 14
0
 bool wordBreak(string s, unordered_set<string>& wordDict) {
     string s2 = '#' + s;
     int size = s2.size();
     vector<bool> possible(size, false);
     possible[0] = true;
     for (int i = 1; i < size; i++) {
         for (int k = 0; k < i; k++) {
             possible[i] = possible[k] &&
                     wordDict.find(s2.substr(k + 1, i - k)) != wordDict.end();
             if (possible[i]) {
                 break;
             }
         }
     }
     return possible[size - 1];
 }
Ejemplo n.º 15
0
Archivo: IO.c Proyecto: asagi09/reversi
int input_move(STONE board[N][N], int turn){
  int X, Y;

  if (!possible(board, turn)){
    printf("You can't set a stone anywhere.\nYou will pass.\n");
    return 0;
  }
  while(1){
    printf("input your move.(1~8): ");
    scanf("%d %d", &X, &Y);
    X--; Y--; // 1~8 -> 0~7
  }

  return set(board, X, Y, turn);
  
}
Ejemplo n.º 16
0
    vector<string> wordBreak(string s, unordered_set<string> &dict) {
        vector<string> res;

        unordered_map<char,vector<string> > capnum;
        for_each(dict.begin(), dict.end(), [&](const string& str){capnum[str[0]].push_back(str);});
        vector<bool> possible(s.length()+1,true);

        auto startwith =[](const string& str, int pos, const string& head){
            for (int i = 0; i < head.length(); ++i) {
                if(pos+i >= str.length() || str[pos+i] != head[i] )
                    return false;
            }
            return true;
        };

        function<bool(int, vector<string>& )> f
                = [&](int pos, vector<string>& vv){
            if(pos >= s.length()){
                string rs = vv[0];
                for (int i = 1; i < vv.size(); ++i) {
                    rs += " " + vv[i];
                }
                res.push_back(move(rs));
                return true;
            }
            if(capnum.count(s[pos]) == 0)
                return false;
            const auto& canv = capnum[s[pos]];
            bool br = false;
            for (auto ss:canv) {
                int len = ss.length();
                if(pos+len <=s.length() && possible[pos+len] && dict.count(ss) && startwith(s, pos, ss)){
                    vv.push_back(ss);
                    bool b = f(pos+len,vv);
                    possible[pos+len] = b;
                    br |= b;
                    vv.pop_back();
                }
            }
            return br;
        };

        vector<string> vv;
        f(0, vv);
        return res;

    }
Ejemplo n.º 17
0
int main()
{
    ull i;
    for(i=0;i<=N;++i) squares[i]=i*i;

    int t;
    scanf("%d",&t);
    ull n;

    for(i=0;i<t;++i)
    {
	scanf("%lld",&n);
	if(possible(n)) printf("Yes\n");
	else printf("No\n");
    }
    return 0;
}
Ejemplo n.º 18
0
void move(int r, int c, int p)
{
	int d, t, o = (p == 'B') ? 'W' : 'B';

	assert(possible(r, c, p));

	a[r][c] = p;
	for (d = 0; d < 8; d++) {
		for (t = 1; valid(r + t * dr[d], c + t * dc[d]); t++)
			if (a[r + t * dr[d]][c + t * dc[d]] != o) break;
		if (t < 2 || !valid(r + t * dr[d], c + t * dc[d])) continue;
		if (a[r + t * dr[d]][c + t * dc[d]] != p) continue;

		for (t = 1; valid(r + t * dr[d], c + t * dc[d]); t++) {
			if (a[r + t * dr[d]][c + t * dc[d]] != o) break;
			a[r + t * dr[d]][c + t * dc[d]] = p;
		}
	}
}
Ejemplo n.º 19
0
bool PackingRects::pack(const Size& size)
{
  m_bounds = Rect(size).shrink(m_borderPadding);

  // We cannot sort m_rects because we want to
  std::vector<Rect*> rectPtrs(m_rects.size());
  int i = 0;
  for (auto& rc : m_rects)
    rectPtrs[i++] = &rc;
  std::sort(rectPtrs.begin(), rectPtrs.end(), by_area);

  gfx::Region rgn(m_bounds);
  for (auto rcPtr : rectPtrs) {
    gfx::Rect& rc = *rcPtr;

    // The rectangles are treated as its original size during placement,
    // but occupies an extra border of <shapePadding> pixels once its
    // position has been determined.
    // This ensures that all rectangles are padded by <sp> pixels,
    // and are still placed correctly near edges, e.g. when remaining
    // horizontal space is between <width> and <width>+<shapePadding>.
    for (int v=0; v<=m_bounds.h-rc.h; ++v) {
      for (int u=0; u<=m_bounds.w-rc.w; ++u) {
        gfx::Rect possible(m_bounds.x + u, m_bounds.y + v, rc.w, rc.h);
        Region::Overlap overlap = rgn.contains(possible);
        if (overlap == Region::In) {
          rc = possible;
          rgn.createSubtraction(
            rgn,
            gfx::Region(Rect(rc).inflate(m_shapePadding))
          );
          goto next_rc;
        }
      }
    }
    return false; // There is not enough room for "rc"
  next_rc:;
  }

  return true;
}
Ejemplo n.º 20
0
void Connect4::computerPlay() {
	int score, bestMove, bestScore;
	int nply = difficulty;
	int *pMoves = possible();

	printf("nply: %d \nScores :", nply);
	if (player == 1) {
		bestScore = -1000000000;
		for (int k=0; k<NB_COLUMNS; k++) {
			if (pMoves[k]==1) {
				playAtColumn(k);
				score = abPruning(1000000000, -1000000000, nply);
				printf("%d ", score);
				if ( score > bestScore) {
					bestScore = score;
					bestMove = k;
				}
				unplayAtColumn(k);
			}
		}
		printf("\n");
	}
	if (player == -1) {
		bestScore = 1000000000;
		for (int k=0; k<NB_COLUMNS; k++) {
			if (pMoves[k]==1) {
				playAtColumn(k);
				score = abPruning(1000000000, -1000000000, nply);
				printf("%d ", score);
				if ( score < bestScore) {
					bestScore = score;
					bestMove = k;
				}
				unplayAtColumn(k);
			}
		}
		printf("\n");
	}
	playAtColumn(bestMove);
}
Ejemplo n.º 21
0
void randomTree(Graph &G, int n, int maxDeg, int maxWidth)
{
	G.clear();

	if (n <= 0) return;
	if (maxDeg   <= 0) maxDeg   = n;
	if (maxWidth <= 0) maxWidth = n;

	int max = 0;
	Array<node> possible(n);
	Array<int> width(0,n,0);
	NodeArray<int> level(G,0);

	level[possible[0] = G.newNode()] = 0;
	--n;

	while(n > 0) {
		int  i = randomNumber(0,max);
		node v = possible[i];

		if (width[level[v]+1] == maxWidth) {
			possible[i] = possible[max--];
			continue;
		}

		if (v->outdeg()+1 == maxDeg)
			possible[i] = possible[max--];

		node w = G.newNode();
		possible[++max] = w;
		G.newEdge(v,w);
		width[level[w] = level[v]+1]++;

		--n;
	}
}
Ejemplo n.º 22
0
    }
  }
}

/*
 * Outputs usage information. Invoked by -h or when an erroneous argument is
 * given
 */
void
usage (char *self)
{
  printf (_ ("Usage: %s [OPTION]... [FILE]...\n\
  --mean, -m\t\t\tPrint mean only\n\
  --stdev, -s\t\t\tPrint standard deviation only\n\
  --stdev-variance -V\t\tPrint variance (standard deviation) only\n\
  --population-stdev, -S\tPrint population standard deviation only\n\
  --population-variance, -w\tPrint variance (population standard deviation) only\n\
  --median, -M\t\t\tPrint median only\n\
  --mode, -f\t\t\tPrint mode only\n"), self);
  /* Broken into two because of the 510 byte "limit" in c89 */
  printf (_ ("  --num-elements, -e\t\tPrint number of elements only\n\
  --print-values, -p\t\tPrint out sorted values (not printed in normal output if omitted)\n\
  --maxmin, -o\t\t\tPrint max and min values only\n\
  --sum, -t\t\t\tPrint sum only\n"));
  printf (_ ("  --assume-sorted, -a\t\tAssume sorted input - avoids sorting overhead\n\
  --ignore-noise, -i\t\tIgnore lines with garbage input as much as possible (ie. tolerate 5M and ignore lines not beginning with numbers)\n\
  --help, -h\t\t\tPrint this help text and exit\n\
  --version, -v\t\t\tPrint version information and exit\n"));
  exit (EXIT_FAILURE);
}
Ejemplo n.º 23
0
// we have a segment, in NFD. Find all the strings that are canonically equivalent to it.
UnicodeString* CanonicalIterator::getEquivalents(const UnicodeString &segment, int32_t &result_len, UErrorCode &status) {
    Hashtable result(status);
    Hashtable permutations(status);
    Hashtable basic(status);
    if (U_FAILURE(status)) {
        return 0;
    }
    result.setValueDeleter(uprv_deleteUObject);
    permutations.setValueDeleter(uprv_deleteUObject);
    basic.setValueDeleter(uprv_deleteUObject);

    UChar USeg[256];
    int32_t segLen = segment.extract(USeg, 256, status);
    getEquivalents2(&basic, USeg, segLen, status);

    // now get all the permutations
    // add only the ones that are canonically equivalent
    // TODO: optimize by not permuting any class zero.

    const UHashElement *ne = NULL;
    int32_t el = UHASH_FIRST;
    //Iterator it = basic.iterator();
    ne = basic.nextElement(el);
    //while (it.hasNext())
    while (ne != NULL) {
        //String item = (String) it.next();
        UnicodeString item = *((UnicodeString *)(ne->value.pointer));

        permutations.removeAll();
        permute(item, CANITER_SKIP_ZEROES, &permutations, status);
        const UHashElement *ne2 = NULL;
        int32_t el2 = UHASH_FIRST;
        //Iterator it2 = permutations.iterator();
        ne2 = permutations.nextElement(el2);
        //while (it2.hasNext())
        while (ne2 != NULL) {
            //String possible = (String) it2.next();
            //UnicodeString *possible = new UnicodeString(*((UnicodeString *)(ne2->value.pointer)));
            UnicodeString possible(*((UnicodeString *)(ne2->value.pointer)));
            UnicodeString attempt;
            nfd.normalize(possible, attempt, status);

            // TODO: check if operator == is semanticaly the same as attempt.equals(segment)
            if (attempt==segment) {
                //if (PROGRESS) printf("Adding Permutation: %s\n", UToS(Tr(*possible)));
                // TODO: use the hashtable just to catch duplicates - store strings directly (somehow).
                result.put(possible, new UnicodeString(possible), status); //add(possible);
            } else {
                //if (PROGRESS) printf("-Skipping Permutation: %s\n", UToS(Tr(*possible)));
            }

            ne2 = permutations.nextElement(el2);
        }
        ne = basic.nextElement(el);
    }

    /* Test for buffer overflows */
    if(U_FAILURE(status)) {
        return 0;
    }
    // convert into a String[] to clean up storage
    //String[] finalResult = new String[result.size()];
    UnicodeString *finalResult = NULL;
    int32_t resultCount;
    if((resultCount = result.count())) {
        finalResult = new UnicodeString[resultCount];
        if (finalResult == 0) {
            status = U_MEMORY_ALLOCATION_ERROR;
            return NULL;
        }
    }
    else {
        status = U_ILLEGAL_ARGUMENT_ERROR;
        return NULL;
    }
    //result.toArray(finalResult);
    result_len = 0;
    el = UHASH_FIRST;
    ne = result.nextElement(el);
    while(ne != NULL) {
        finalResult[result_len++] = *((UnicodeString *)(ne->value.pointer));
        ne = result.nextElement(el);
    }


    return finalResult;
}
Ejemplo n.º 24
0
Archivo: main.c Proyecto: sylafrs/Dames
int main(int argc, char *argv[])
{
    SDL_Surface *ecran = NULL;                      //surface affichée à l'ecran
    SDL_Event event;                                //stock l'evenement

    Case plateau[TAILLE_PLATEAU][TAILLE_PLATEAU];   //le plateau
    Case precedent[TAILLE_PLATEAU][TAILLE_PLATEAU]; //le plateau precedent (pour annuler)

    Joueur joueur;                                  //à qui le tour ?

    bool continuer = true;                          //booléen pour rester dans la boucle
    bool fin = false;                               //booléen declenchant la fin du programme
    bool appuiAbandon = false, appuiAnnuler = false;//les boutons
    bool peutAnnuler;                               //si on peut appuyer sur annuler
    bool selection;                                 //une case est-elle selectionnée
    int cliqueeX = 0, cliqueeY = 0;                 //si oui : quelles sont ces coordonnées ?
    char cause[10];                                 //chaine pour la fin...

    // Démarrage de la SDL, et de la bibliotheque de police.
    SDL_Init(SDL_INIT_VIDEO);
    TTF_Init();

    //Ouverture de la fenetre
    #ifdef FULLSCREEN
        ecran = SDL_SetVideoMode(ECRAN_X, ECRAN_Y, NB_COULEURS, SDL_HWSURFACE|SDL_FULLSCREEN);
    #else
        ecran = SDL_SetVideoMode(ECRAN_X, ECRAN_Y, NB_COULEURS, SDL_HWSURFACE);
    #endif

    // On change le titre
    SDL_WM_SetCaption(TITRE_FENETRE, NULL);

    do
    {
        //initialisation des variables
        selection = false; // aucune case ne doit etre cliquee (securite)
        joueur = blanc; // les blancs commencent toujours

        //On initialise le plateau
        reinitialiser(plateau);
        peutAnnuler = false;

        do
        {
            //Affichage
            afficher(plateau, joueur, ecran, selection, cliqueeX, cliqueeY, appuiAbandon, appuiAnnuler);

            //Entree
            SDL_WaitEvent(&event);

            //Gestion (selon le type de l'evenement)

            //appui sur la croix (fenetre)
            if(event.type == SDL_QUIT)
                fin = true; //on s'en va...

            //appui sur une touche
            else if(event.type == SDL_KEYDOWN)
            {
                //la touche etant Echap
                if(event.key.keysym.sym == SDLK_ESCAPE)
                    fin = true; //on s'en va...
            }

            //bouton de la souris relaché
            else if(event.type == SDL_MOUSEBUTTONUP)
            {
                //c'etait un clic gauche
                if(event.button.button == SDL_BUTTON_LEFT)
                {
                    //on avais cliqué sur annuler
                    if(appuiAnnuler)
                    {
                        //si on peut annuler
                        if(peutAnnuler)
                        {
                            //on ne le peut plus
                            peutAnnuler = false;
                            //le plateau actuel est le plateau d'avant
                            egalPlateau(plateau, precedent);
                            //on redonne la main au joueur precedent
                            joueur = (joueur == noir) ? blanc : noir;
                            //aucune case cliquee
                            selection = false;
                        }

                        //bouton annuler : relaché
                        appuiAnnuler = false;
                    }

                    //on avais cliqué sur abandon
                    else if(appuiAbandon)
                    {
                        //c'est l'autre joueur qui gagne
                        joueur = (joueur == blanc) ? noir : blanc;
                        //bouton abandon : relaché
                        appuiAbandon = false;
                        //fin de la partie
                        continuer = false;
                        //la cause etant l'abandon
                        sprintf(cause, "abandon");
                    }
                }
            }

            //appui sur un bouton de la souris
            else if(event.type == SDL_MOUSEBUTTONDOWN)
            {
                //clic gauche
                if(event.button.button == SDL_BUTTON_LEFT)
                {
                    //on appuie sur le bouton annuler
                    if(event.button.x > BOUTON_ANNULER_X && event.button.x < BOUTON_ANNULER_X+TAILLE_BOUTON_X && event.button.y > BOUTON_ANNULER_Y && event.button.y < BOUTON_ANNULER_Y+TAILLE_BOUTON_Y)
                        appuiAnnuler = true;

                    //on appuie sur le bouton abandon
                    else if(event.button.x > BOUTON_ABANDON_X && event.button.x < BOUTON_ABANDON_X+TAILLE_BOUTON_X && event.button.y > BOUTON_ABANDON_Y && event.button.y < BOUTON_ABANDON_Y+TAILLE_BOUTON_Y)
                        appuiAbandon = true;

                    //on clique dans la zone de jeu
                    else if(event.button.x > ZDJ_X && event.button.x < ZDJ_X+ZDJ && event.button.y > ZDJ_Y && event.button.y < ZDJ_Y+ZDJ)
                    {
                        //si on avais dejà selectionné quelque chose
                        if(selection)
                        {
                            //si le deplacement est autorise
                            if(possible(plateau, cliqueeX, cliqueeY, ((event.button.x-ZDJ_X)/TAILLE_CASES), ((event.button.y-ZDJ_Y)/TAILLE_CASES)))
                            {
                                //(se deplacer), et si quelque chose a été mangé
                                if(manger(plateau, cliqueeX, cliqueeY, ((event.button.x-ZDJ_X)/TAILLE_CASES), ((event.button.y-ZDJ_Y)/TAILLE_CASES)))
                                {
                                    //le pion est toujours selectionnable, mais à son nouvel
                                    //emplacement
                                    cliqueeX = ((event.button.x-ZDJ_X)/TAILLE_CASES);
                                    cliqueeY = ((event.button.y-ZDJ_Y)/TAILLE_CASES);

                                    //a t-on gagne par victoire totale ?
                                    //si oui, on sort de la partie
                                    continuer = !gagner(plateau, joueur);

                                    if(!continuer)
                                         sprintf(cause, "victoire totale");

                                    //sinon, si on ne peut plus manger --> au joueur suivant !
                                    else if(!peutManger(plateau, cliqueeX, cliqueeY))
                                    {
                                        //on deselectionne le pion
                                        selection = false;
                                        //on change de joueur
                                        joueur = (joueur == blanc) ? noir : blanc;
                                        //on peut revenir en arriere
                                        peutAnnuler = true;

                                        //sommes-nous bloqué ?
                                        continuer = !bloque(plateau, joueur);
                                        if(!continuer)
                                        {
                                            sprintf(cause, "blocage");

                                            //si oui, c'est l'autre joueur,
                                            //celui qui vient de jouer, qui gagne !
                                            joueur = (joueur == blanc) ? noir : blanc;
                                        }

                                    }
                                }

                                //rien a été mangé : au joueur suivant !
                                else
                                {
                                    //on deselectionne le pion
                                    selection = false;
                                    //on change de joueur
                                    joueur = (joueur == blanc) ? noir : blanc;
                                    //on peut revenir en arriere
                                    peutAnnuler = true;
                                }
                            }
                        }

                        //sinon, si on clique sur un pion
                        else if(plateau[(event.button.x-ZDJ_X)/TAILLE_CASES][(event.button.y-ZDJ_Y)/TAILLE_CASES].pion != non)
                        {
                            //coordonnees du pion en question
                            cliqueeY = (event.button.y-ZDJ_Y)/TAILLE_CASES;
                            cliqueeX = (event.button.x-ZDJ_X)/TAILLE_CASES;

                            //si on peut selectionner ce pion
                            if(plateau[cliqueeX][cliqueeY].joueur == joueur && selectionnable(plateau, cliqueeX, cliqueeY))
                            {
                                //le prochain plateau precedent est le plateau actuel
                                egalPlateau(precedent, plateau);
                                //le pion est selectionné
                                selection = true;
                                //on ne peut plus annuler (il faudra d'abord cliquer sur une case)
                                peutAnnuler = false;
                            }
                        }
                    }
                }
            }
        //Gestion terminée

        //repeter ceci tant que la partie nest pas terminée, et que l'on ne veut pas s'en aller
        }while (continuer && !fin);

        //securité...
        appuiAbandon = false;
        appuiAnnuler = false;

        //considerons ici abandon <-> quitter et annuler <-> recommencer

        //tant que l'on a pas choisi...
        while(!continuer && !fin)
        {
            //on affiche le message de fin
            affichageFin(plateau, ecran, appuiAnnuler, appuiAbandon, joueur, cause);

            //si il y a un evenement
            SDL_WaitEvent(&event);

            //de type : "boutton de sourie relaché"
            if(event.type == SDL_MOUSEBUTTONUP)
            {
                //si le bouton en question est le gauche
                if(event.button.button == SDL_BUTTON_LEFT)
                {
                    //si on avais appuyé sur recommencer
                    if(appuiAnnuler)
                    {
                        //on relache le bouton
                        appuiAnnuler = false;
                        //on recommence une partie
                        continuer = true;
                    }
                    //sinon si on avais appuyé sur arreter
                    else if(appuiAbandon)
                    {
                        //on relache le bouton
                        appuiAbandon = false;
                        //on s'en va
                        fin = true;
                    }
                }
            }

            //de type : "appui sur une bouton de la souris"
            else if(event.type == SDL_MOUSEBUTTONDOWN)
            {
                //clic gauche
                if(event.button.button == SDL_BUTTON_LEFT)
                {
                    //sur le bouton "oui" (recommencer (annuler))
                    if(event.button.x > FIN_BOUTON_OUI_X && event.button.x < FIN_BOUTON_OUI_X+TAILLE_BOUTON_X && event.button.y > FIN_BOUTON_OUI_Y && event.button.y < FIN_BOUTON_OUI_Y+TAILLE_BOUTON_Y)
                        appuiAnnuler = true;

                    //sur le bouton "non" (arreter (abandon))
                    else if(event.button.x > FIN_BOUTON_NON_X && event.button.x < FIN_BOUTON_NON_X+TAILLE_BOUTON_X && event.button.y > FIN_BOUTON_NON_Y && event.button.y < FIN_BOUTON_NON_Y+TAILLE_BOUTON_Y)
                        appuiAbandon = true;
                }
            }

            //de type : "appui sur la croix de la fenetre"
            else if(event.type == SDL_QUIT)
                fin = true;

            //de type : "appui sur une touche"
            else if(event.type == SDL_KEYDOWN)
            {
                //la touche Echap
                if(event.key.keysym.sym == SDLK_ESCAPE)
                    fin = true;
            }
        }

    //tant que l'on ne veut pas s'en aller
    }while(!fin);

    //arret de la SDL et de la biblio des polices
    TTF_Quit();
    SDL_Quit();

    //tout s'est bien passé
    return EXIT_SUCCESS;
}
Ejemplo n.º 25
0
int main(int argc, char **argv) {
    
  mint maxLen = 0;
  mint nNodes = 0;
  mint ** coords;
  mdouble ** dists;
  
  string file = "../examples/pub02";

  string s;
  char buff[6];
  stringstream ss;
  
  
#if DBG
  string inadr = file;
  ifstream inFile (inadr.append(".in").data());  
  getline(inFile,s);    
#else
  getline(cin,s);
#endif
  ss << s;
  ss.getline(buff,6,' ');
  nNodes = (mint)(atoi(buff));
    
 // TODO buff se mozna musi  po pouziti zas smazat
    
  ss.getline(buff,6,' ');
  maxLen = (mint)(atoi(buff));
    
  //scout << nNodes << " " << maxLen << endl;
  
  coords = new mint * [nNodes];
  
  for(mint i=0;i<nNodes;i++){
    coords[i] = new mint[2];
  }
  
  dists = new mdouble * [nNodes];
  
  for(mint i=0;i<nNodes;i++){
    dists[i] = new mdouble[nNodes];
  }
  

    
#if DBG
  for(mint i=0;i<nNodes;i++){
    s.clear();
    ss.clear();
    
    getline(inFile,s);
    ss << s;
    
    ss.getline(buff,6,' ');
    coords[i][0] = (mint)(atoi(buff));
    ss.getline(buff,6,' ');
    coords[i][1] = (mint)(atoi(buff));
  }
  
  inFile.close();
  
#else
  for(mint i=0;i<nNodes;i++){
    s.clear();
    ss.clear();
    
    getline(cin,s);
    ss << s;

    ss.getline(buff,6,' ');
    coords[i][0] = (mint)(atoi(buff));
    ss.getline(buff,6,' ');
    coords[i][1] = (mint)(atoi(buff));
  }
#endif
    
#if DBG
  
  ifstream fileStream (file.append(".out").data());  
  s.clear();
  getline(fileStream,s);
  cout << "Correct result: " << s << endl;
  fileStream.close();
#endif
  
/*/  for(mint i=0;i<nNodes;i++){
    for(mint j=0;j<2;j++){
      cout << coords[i][j] << " ";
    }
    
    cout << endl;
  }
/**/  

  for(mint i=0;i<nNodes;i++){
    for(mint j=0;j<nNodes;j++){
      if(j>i){
	dists[i][j]=dist(coords[i][0],coords[i][1],coords[j][0],coords[j][1]);
      } else if (j<i) {
	dists[i][j] = dists[j][i];
      } else {
	dists[i][i]=0;
      }
    }
  }
  
  mint **** conflicts = new mint *** [nNodes];
  
  for(mint i=0;i<nNodes;i++){
    conflicts[i] = new mint ** [nNodes];
    for(mint j=0;j<nNodes;j++){
      conflicts[i][j] = new mint * [nNodes];
      for(mint k=0;k<nNodes;k++){
	conflicts[i][j][k] = new mint[nNodes];
	for(mint l=0;l<nNodes;l++){
	  conflicts[i][j][k][l]=intersects(coords[i],coords[j],coords[k],coords[l]);
	}
      }
    }
  }
  
  /*for(mint i=0;i<nNodes;i++){
    for(mint j=0;j<nNodes;j++){
      cout << dists[i][j] << " ";
    }
    cout << endl;
  }/**/
  
  list<Node *> * oldGen = new list<Node *>();
  list<Node *> * newGen = new list<Node *>();
  list<Node *>::iterator it;
  
  mint level = 0;
  
  // bit mask of available vertices
  mint avVertices = pow(2,nNodes) - 1;
  
  for(mint i = 0;i<nNodes;i++){
    Node * n = new Node(0);
    n->avNodesMask = avVertices xor 1 << i;
  //  cout <<"Node #: " << i << " AvNodeMask: " << (bitset<16>) n->avNodesMask << endl;
    n->nodes->push_back(i);
    oldGen->push_back(n);
  }
  
for(it=oldGen->begin();it!=oldGen->end();++it){
  //    cout << "next from old: " << endl;
      
 //     (*it)->printNode();
    
      for(mint i=0;i<nNodes;i++){
//	cout << "next to add: " << i << endl;
	 
	 if((*it)->avNodesMask & 1 << i){
		mdouble len = (*it)->len + dists[(*it)->nodes->back()][i];
		Node * n = new Node(len);
		
		list<mint>::iterator ns;
	      
		ns = (*it)->nodes->begin();
		
		for(ns;ns!=(*it)->nodes->end();++ns){
		  n->nodes->push_back(*ns);
		  //cout << *ns << endl;
		}
		
		n->nodes->push_back(i);
		
		n->avNodesMask = (*it)->avNodesMask xor 1 << i;
		
//		cout << "added: " << i << endl;
		newGen->push_back(n);
		
		//break;
	      	   
	 }
	 
      }
      
      newGen->pop_back();
      
    }
 
    deleteNodeList(oldGen);
    oldGen->clear();
    delete oldGen;
    
    oldGen=newGen;
    
    level++;
  
   /**/ while(level<nNodes){
    
   // oldGenSize = oldGen->size();
    
    newGen = new list<Node *>();
    
    
    for(it=oldGen->begin();it!=oldGen->end();++it){
  //    cout << "next from old: " << endl;
      
 //     (*it)->printNode();
    
      for(mint i=0;i<nNodes;i++){
//	cout << "next to add: " << i << endl;
	 
	 if((*it)->avNodesMask & 1 << i){
	   if(possible(conflicts,(*it)->nodes,i)){
	      
	      mdouble addedToFirstDist = dists[i][(*it)->nodes->front()];
	      mdouble len = (*it)->len + dists[(*it)->nodes->back()][i];
	      
	      if (len + addedToFirstDist <= maxLen) {
		Node * n = new Node(len);
		
		list<mint>::iterator ns;
	      
		ns = (*it)->nodes->begin();
		
		for(ns;ns!=(*it)->nodes->end();++ns){
		  n->nodes->push_back(*ns);
		  //cout << *ns << endl;
		}
		
		n->nodes->push_back(i);
		
		n->avNodesMask = (*it)->avNodesMask xor 1 << i;
		
//		cout << "added: " << i << endl;
		newGen->push_back(n);
		
		//break;
	      }
	   }
	   
	 }
	 
      }
      
    }
    
    if(newGen->empty() || level+1 == nNodes){
      it = oldGen->begin();
      list<mint>::iterator iter;
      Node * chosen = *it;
      mdouble mLen = (*it)->len + dists[chosen->nodes->front()][chosen->nodes->back()];
      mint n = (*it)->nodes->size();
      
      for(it;it!=oldGen->end();++it){
	
        mdouble tmp = (*it)->len + dists[(*it)->nodes->front()][(*it)->nodes->back()];
	
	if (tmp < mLen){
	  mLen = tmp;
	  chosen = *it;
	}
      }
      
      

      
      cout << (int)ceil(mLen) << endl;
      break;
    }
    
    deleteNodeList(oldGen);
    oldGen->clear();
    delete oldGen;
    
    oldGen=newGen;
    
    level++;
  }/**/
  
  
  for(mint i=0;i<nNodes;i++) delete [] coords[i];
  for(mint i=0;i<nNodes;i++) delete [] dists[i];
  
  for(mint i=0;i<nNodes;i++){
    for(mint j=0;j<nNodes;j++){
      for(mint k=0;k<nNodes;k++){
	
	  delete [] conflicts[i][j][k];
	
      }
      delete [] conflicts[i][j];
    }
    delete [] conflicts[i];
  }
  
  delete [] dists;
  delete [] coords;
  delete [] conflicts;
  
  deleteNodeList(oldGen);
  delete oldGen;
 // deleteNodeList(newGen);
//  delete newGen;
  return 0;
}
Ejemplo n.º 26
0
// the overall motion of ghost
     void motion(int &xg,int &yg,int x,int y,char &cg,int blackSquare[][28],int &ig,int &v){
		int p=xg-44;int q=yg-50;
//v is used to make ghost follow pac only for particular time interval

	if(((ab((x-xg))+ab((y-yg)))<200)&&(v<=3)){v++;

	if(cg=='w'){if((p%20==0)&&(q%20==0)&&((blackSquare[(q/20)][(p/20)-1]==1)||(blackSquare[(q/20)][(p/20)+1]==1)))
	{shortestPath(xg,yg,x,y,cg,blackSquare);return;}
	            else{yg=yg-5;return;}};
	if(cg=='a'){if((p%20==0)&&(q%20==0)&&((blackSquare[(q/20)-1][(p/20)]==1)||(blackSquare[(q/20)+1][(p/20)]==1)))
	{shortestPath(xg,yg,x,y,cg,blackSquare);return;}
	            else{{xg=xg-5;return;}};}
	if(cg=='s'){if((p%20==0)&&(q%20==0)&&((blackSquare[(q/20)][(p/20)-1]==1)||(blackSquare[(q/20)][(p/20)+1]==1)))
	{shortestPath(xg,yg,x,y,cg,blackSquare);return;}
	            else{yg=yg+5;return;}};
	if(cg=='d'){if((p%20==0)&&(q%20==0)&&((blackSquare[(q/20)-1][(p/20)]==1)||(blackSquare[(q/20)+1][(p/20)]==1)))
	{shortestPath(xg,yg,x,y,cg,blackSquare);return;}
	            else{xg=xg+5;return;}}};
    v=0;
	if(ig%5==1){
	if(cg!='s'){if(possible(xg,yg,cg,'w',blackSquare)){cg='w';yg=yg-5;ig++;return;}};
	if(cg!='a'){if(possible(xg,yg,cg,'d',blackSquare)){cg='d',xg=xg+5;ig++;return;}};
	if(cg!='w'){if(possible(xg,yg,cg,'s',blackSquare)){cg='s';yg=yg+5;ig++;return;}};
	if(cg!='d'){if(possible(xg,yg,cg,'a',blackSquare)){cg='a';xg=xg-5;ig++;return;}};
	};

	if(ig%5==2){
	if(cg!='a'){if(possible(xg,yg,cg,'d',blackSquare)){cg='d',xg=xg+5;ig++;return;}};
	if(cg!='s'){if(possible(xg,yg,cg,'w',blackSquare)){cg='w';yg=yg-5;ig++;return;}};
	if(cg!='d'){if(possible(xg,yg,cg,'a',blackSquare)){cg='a';xg=xg-5;ig++;return;}};
	if(cg!='w'){if(possible(xg,yg,cg,'s',blackSquare)){cg='s';yg=yg+5;ig++;return;}};
	};
	
	if(ig%5==3){
	if(cg!='d'){if(possible(xg,yg,cg,'a',blackSquare)){cg='a';xg=xg-5;ig++;return;}};
	if(cg!='w'){if(possible(xg,yg,cg,'s',blackSquare)){cg='s';yg=yg+5;ig++;return;}};
	if(cg!='s'){if(possible(xg,yg,cg,'w',blackSquare)){cg='w';yg=yg-5;ig++;return;}};
	if(cg!='a'){if(possible(xg,yg,cg,'d',blackSquare)){cg='d',xg=xg+5;ig++;return;}};};
	
	if(ig%5==4){
	if(cg!='w'){if(possible(xg,yg,cg,'s',blackSquare)){cg='s';yg=yg+5;ig++;return;}};
	if(cg!='s'){if(possible(xg,yg,cg,'w',blackSquare)){cg='w';yg=yg-5;ig++;return;}};
	if(cg!='d'){if(possible(xg,yg,cg,'a',blackSquare)){cg='a';xg=xg-5;ig++;return;}};
	if(cg!='a'){if(possible(xg,yg,cg,'d',blackSquare)){cg='d',xg=xg+5;ig++;return;}};};
	
	if(ig%5==0){
	if(cg!='s'){if(possible(xg,yg,cg,'w',blackSquare)){cg='w';yg=yg-5;ig++;return;}};
	if(cg!='w'){if(possible(xg,yg,cg,'s',blackSquare)){cg='s';yg=yg+5;ig++;return;}};
	if(cg!='d'){if(possible(xg,yg,cg,'a',blackSquare)){cg='a';xg=xg-5;ig++;return;}};
	if(cg!='a'){if(possible(xg,yg,cg,'d',blackSquare)){cg='d',xg=xg+5;ig++;return;}};};
	
	}
 bool isUnivalTree(TreeNode* root) {
     if( root == NULL ) return true;
     int val = root -> val;
     return possible(root, val);
 }
Ejemplo n.º 28
0
void shortestPath(int &xg,int &yg,int x,int y,char &cg,int blackSquare[][28]){
//ghosts finds the shortest path to pac man and follows it

       if(((x-xg)>0)&&((y-yg)>0)){
	   if(cg!='a'){if(possible(xg,yg,cg,'d',blackSquare)){xg=xg+5;cg='d';return;}};
       if(cg!='w'){ if(possible(xg,yg,cg,'s',blackSquare)){yg=yg+5;cg='s';return;}};
       if(cg!='d') {if(possible(xg,yg,cg,'a',blackSquare)){xg=xg-5;cg='a';return;}};
       if(cg!='s'){if(possible(xg,yg,cg,'w',blackSquare)){yg=yg-5;cg='w';return;}};
       };
        
   if(((x-xg)<0)&&((y-yg)>0)){
	   if(cg!='d'){if(possible(xg,yg,cg,'a',blackSquare)){xg=xg-5;cg='a';return;}};
       if(cg!='w') {if(possible(xg,yg,cg,'s',blackSquare)){yg=yg+5;cg='s';return;}};
       if(cg!='s'){ if(possible(xg,yg,cg,'w',blackSquare)){yg=yg-5;cg='w';return;}};
       if(cg!='a'){if(possible(xg,yg,cg,'d',blackSquare)){xg=xg+5;cg='d';return;}};
       };
        
   if(((x-xg)<0)&&((y-yg)<0)){
	   if(cg!='d'){if(possible(xg,yg,cg,'a',blackSquare)){xg=xg-5;cg='a';return;}};
       if(cg!='s'){if(possible(xg,yg,cg,'w',blackSquare)){yg=yg-5;cg='w';return;}};
       if(cg!='a') { if(possible(xg,yg,cg,'d',blackSquare)){xg=xg+5;cg='d';return;}};
       if(cg!='w'){if(possible(xg,yg,cg,'s',blackSquare)){yg=yg+5;cg='s';return;}};
      };
 
   if(((x-xg)>0)&&((y-yg)<0)){
	   if(cg!='s'){if(possible(xg,yg,cg,'w',blackSquare)){yg=yg-5;cg='w';return;}};
       if(cg!='a'){if(possible(xg,yg,cg,'d',blackSquare)){xg=xg+5;cg='d';return;}};
       if(cg!='w'){if(possible(xg,yg,cg,'s',blackSquare)){yg=yg-5;cg='s';return;}};
	   if(cg!='d'){if(possible(xg,yg,cg,'a',blackSquare)){xg=xg-5;cg='a';return;}};
        };
        
     if(((x-xg)==0)&&((y-yg)>0)){ 
	  if(cg!='w'){if(possible(xg,yg,cg,'s',blackSquare)){yg=yg+5;cg='s';return;}};
      if(cg!='a')  {if(possible(xg,yg,cg,'d',blackSquare)){xg=xg+5;cg='d';return;}};
	  if(cg!='d') { if(possible(xg,yg,cg,'a',blackSquare)){xg=xg-5;cg='a';return;}};
	  if(cg!='s'){if(possible(xg,yg,cg,'w',blackSquare)){yg=yg-5;cg='w';return;}};
	  }
	
	  if(((x-xg)==0)&&((y-yg)<0)){ 
		   if(cg!='s'){if(possible(xg,yg,cg,'w',blackSquare)){yg=yg-5;cg='w';return;}};
	  if(cg!='d') { if(possible(xg,yg,cg,'a',blackSquare)){xg=xg-5;cg='a';return;}};
	   if(cg!='a') {if(possible(xg,yg,cg,'d',blackSquare)){xg=xg+5;cg='d';return;}};
	    if(cg!='w'){if(possible(xg,yg,cg,'s',blackSquare)){yg=yg+5;cg='s';return;}};
	   }
	
	
     if(((y-yg)==0)&&((x-xg)<0)){  
	  if(cg!='d') { if(possible(xg,yg,cg,'a',blackSquare)){xg=xg-5;cg='a';return;}};
	  if(cg!='s')  {if(possible(xg,yg,cg,'w',blackSquare)){yg=yg-5;cg='w';return;}};
     if(cg!='w') {  if(possible(xg,yg,cg,'s',blackSquare)){yg=yg+5;cg='s';return;}};
      if(cg!='a'){if(possible(xg,yg,cg,'d',blackSquare)){xg=xg+5;cg='d';return;}};
     };
                                                                       
       if(((y-yg)==0)&&((x-xg)>0)){  
	  if(cg!='a') { if(possible(xg,yg,cg,'d',blackSquare)){xg=xg+5;cg='d';return;}};
      if(cg!='w') { if(possible(xg,yg,cg,'s',blackSquare)){yg=yg+5;cg='s';return;}};
      if(cg!='s') { if(possible(xg,yg,cg,'w',blackSquare)){yg=yg-5;cg='w';return;};}
       if(cg!='d'){if(possible(xg,yg,cg,'a',blackSquare)){xg=xg-5;cg='a';return;}};
      };}
 bool possible(TreeNode* root, int val){
     if( root == NULL ) return true;
     if( root -> val != val ) return false;
     return possible(root -> left, val) & possible(root -> right, val);
 }