int Len(TIntVector v, bool print) { int result = 0; if (print) { Out(v); printf("\n"); } for (size_t i = 0; i < v.size(); ++i) { size_t j = 0; while ( v[j] != i ) ++j; if (j != i) { TIntVector nw; for (size_t k = 0; k < i; ++k) nw.push_back(v[k]); if (j + 1 != v.size()) { for (size_t k = j; k < v.size(); ++k) nw.push_back(v[k]); for (size_t k = i; k < j; ++k) nw.push_back(v[i + (j - k) - 1]); result += 2; } else { for (size_t k = i; k < v.size(); ++k) nw.push_back(v[v.size() - k + i - 1]); ++result; } v.swap(nw); if (print) { Out(v); printf(" %d\n", result); } } } return result; }
void end( const TWallVertexVector& vb, TIntVector& polygon, TIntVector& ib ) { assert( polygonCount ); if( polygonCount == 1 ) { // trivial case, just output input polygon polygon.resize( 0 ); polygon.reserve( vertices.size() ); int idx0 = *vertices.begin(); int idx = idx0; do { polygon.push_back( idx ); const TIntVector& vnext = vertexNexts[idx]; assert( vnext.size() == 1 ); idx = vnext[0]; } while( idx != idx0 ); triangulator::process( vb, polygon, ib ); } else { // mark vertex types markVertexTypes(); // trace and triangulate the polygon(s) traceBorder( vb, polygon, ib ); } }
void CWall3D::fracturePiecesInYRange( float t, float y1, float y2, TIntVector& pcs ) { if( !mPiecesInited ) initPieces(); // fetch the pieces pcs.resize( 0 ); // TODO: optimize, right now linear search! float pieceRestoreTime = t + 1.0e6f; int n = mWall2D.getPieceCount(); for( int i = 0; i < n; ++i ) { const CWallPiece2D& p = mWall2D.getPiece( i ); SVector2 c = p.getAABB().getCenter(); float y = c.y; if( mMatrix.getAxisY().y < 0.5f ) { SVector3 wc; D3DXVec3TransformCoord( &wc, &SVector3(c.x,c.y,0), &mMatrix ); y = wc.y; } if( y >= y1 && y <= y2 ) { mPieceRestoreTimes[i] = pieceRestoreTime; if( mFracturedPieces[i] ) continue; pcs.push_back( i ); fractureOutPiece( i ); } } }
int main() { string strProblemName = "stamps"; string strInFile = strProblemName + ".in"; string strOutFile = strProblemName + ".out"; ofstream fout ( strOutFile.c_str() ); ifstream fin ( strInFile.c_str() ); if( !fin ) { cout << "open input file fail!" << endl; return 0; } int nMaxStampNum, nStampValueNum; fin >> nMaxStampNum >> nStampValueNum; for ( int i=0; i<nStampValueNum; ++i ) { fin >> arStampValue[ i ]; } int *arValueSumFlag = new int[MAX_VALUE_SUM+1]; memset( arValueSumFlag, 0, sizeof( arValueSumFlag[0] ) * MAX_VALUE_SUM+1 ); typedef std::vector<int> TIntVector; TIntVector tCurSumValue; tCurSumValue.push_back( 0 ); for ( int i=0; i<nMaxStampNum; ++i ) { TIntVector tNewSumValue; for ( int k=0; k<tCurSumValue.size(); ++k ) { for ( int j = 0; j<nStampValueNum; ++j ) { int nSum = tCurSumValue[k] + arStampValue[ j ]; if ( !arValueSumFlag[nSum] ) { tNewSumValue.push_back( nSum ); arValueSumFlag[nSum] = true; // tAllSumValue.insert( nSum ); } } } tCurSumValue = tNewSumValue; } // 找出连续最多的. int nMaxContinueNum = 0; int nMaxContinueTail = 0; int nLastNum = -1; int nCurContinueNum = 1; // int nCurContinueHead = 0; for ( int i=0; i<MAX_VALUE_SUM; ++i ) { if ( !arValueSumFlag[i] ) { continue; } int nCurNum = i; if ( nLastNum+1 == nCurNum ) { // 连续. nCurContinueNum ++; } else { // 不连续了. nCurContinueNum = 1; } nLastNum = nCurNum; if ( nCurContinueNum > nMaxContinueNum ) { nMaxContinueNum = nCurContinueNum; nMaxContinueTail = nLastNum; } } delete[] arValueSumFlag; fout << nMaxContinueTail << endl; fin.close(); fout.close(); #ifdef THINKINGL cout << "use clock: " << clock() << " / " << CLOCKS_PER_SEC << endl; cout << "-----------begin--dump--output--file----------------" << endl << endl; system( ( string( "type " ) + strOutFile ).c_str() ); cout << endl; system( "pause" ); #endif return 0; }
int main() { #ifndef ONLINE_JUDGE ifstream fIn("input.txt"); cin.rdbuf( fIn.rdbuf() ); #endif int n; int m; cin >> n >> m; TBoolVector dummy(2*n, false); TMatrix g(2*n, dummy); for (int i = 0; i < m; ++i) { int a; int b; cin >> a >> b; --a; --b; g[a][b] = true; g[b][a] = true; } for (int i = 0; i < 2 * n; ++i) { g[i][i] = true; } TIntVector s; s.push_back(0); int next = 1; do { int i = next; for (; i < 2 * n; ++i) { int j = 0; while (j < s.size() && !g[s[j]][i]) { ++j; } if (j == s.size()) { break; } } if (i == 2 * n) { next = s.back() + 1; s.pop_back(); } else { next = 1; s.push_back(i); } } while (!s.empty() && s.size() != n); if (s.size() == n) { for (int i = 0; i < 2 * n; ++i) { if (find(s.begin(), s.end(), i) != s.end()) { cout << i + 1 << " "; } } cout << endl; for (int i = 0; i < 2 * n; ++i) { if (find(s.begin(), s.end(), i) == s.end()) { cout << i + 1 << " "; } } cout << endl; } else { cout << "IMPOSSIBLE\n"; } return 0; }
int main() { TIntVector primes; { TBoolVector erato(N + 1, true); for (size_t i = 2; i < N; ++i) { if (erato[i]) { if (i > 1000) { primes.push_back(static_cast<int>(i)); } for (size_t j = i + i; j < erato.size(); j += i) { erato[j] = false; } } } } printf("Primes: %d\n", static_cast<int>(primes.size())); /* TLLIVector powerLB1; FactorialFactorization(LB, primes, &powerLB1); TLLIVector powerLB2; FactorialFactorization(UB - LB, primes, &powerLB2); TLLIVector powerUB; FactorialFactorization(UB, primes, &powerUB); TLLIVector primePowers(primes.size()); size_t zeroes = 0; for (size_t i = 0; i < primes.size(); ++i) { TLLI primePower = powerUB[i] - powerLB1[i] - powerLB2[i]; if (0 == primePower) { ++zeroes; } primePowers[i] = primePower; printf("%d %d\n", static_cast<int>(primes[i]), static_cast<int>(primePower)); } printf("Zeroes: %d\n", static_cast<int>(zeroes)); for (size_t i = 0; i < primes.size(); ++i) { if (!primePowers[i]) { printf("...%d\n", static_cast<int>(i)); int modi = BinomialModPrime(UB, LB, primes[i]); for (size_t j = 0; j < primes.size(); ++j) { if (!primePowers[j]) { int modj = BinomialModPrime(UB, LB, primes[j]); for (size_t k = 0; k < primes.size(); ++k) { if (!primePowers[k]) { int modk = BinomialModPrime(UB, LB, primes[k]); } } } } } } */ for (size_t i = 0; i < primes.size(); ++i) { printf("...%d\n", static_cast<int>(i)); int modi = BinomialModPrime(UB, LB, primes[i]); for (size_t j = 0; j < primes.size(); ++j) { int modj = BinomialModPrime(UB, LB, primes[j]); { for (size_t k = 0; k < primes.size(); ++k) { int modk = BinomialModPrime(UB, LB, primes[k]); printf("%d %d %d\n", modi, modj, modk); } } } } return 0; }
void CWall3D::fracturePiecesInSphere( float t, const SVector3& pos, float radius, TIntVector& pcs, float restoreAfter, float restoreDuration, bool noRestore ) { if( !mPiecesInited ) initPieces(); pcs.resize( 0 ); // to local space SVector3 locPos; D3DXVec3TransformCoord( &locPos, &pos, &mInvMatrix ); if( locPos.z < -radius || locPos.z > radius ) return; // remember restore times if( mResTimeGrid && !noRestore ) { float rad = radius*2.0f; float lx1 = (locPos.x - rad) / mWall2D.getSize().x * RESGRID_X; float lx2 = (locPos.x + rad) / mWall2D.getSize().x * RESGRID_X; float ly1 = (locPos.y - rad) / mWall2D.getSize().y * RESGRID_Y; float ly2 = (locPos.y + rad) / mWall2D.getSize().y * RESGRID_Y; int ix1 = (int)clamp( lx1, 0, RESGRID_X-1 ); int ix2 = (int)clamp( lx2, 0, RESGRID_X-1 ); int iy1 = (int)clamp( ly1, 0, RESGRID_Y-1 ); int iy2 = (int)clamp( ly2, 0, RESGRID_Y-1 ); float dx = mWall2D.getSize().x / RESGRID_X; float dy = mWall2D.getSize().y / RESGRID_Y; for( int iy = iy1; iy <= iy2; ++iy ) { float* resval = mResTimeGrid + RESGRID_X*iy + ix1; float fy = iy * dy; for( int ix = ix1; ix <= ix2; ++ix, ++resval ) { float fx = ix * dx; // don't touch restore grid outside the circle float diffX = fx-locPos.x; float diffY = fy-locPos.y; float diffR2 = diffX*diffX + diffY*diffY; if( diffR2 > rad*rad ) continue; // restore time for this grid point - start at // t+restoreAfter at circle boundaries, later at circle // center float resTime = t + restoreAfter + (1.0f-diffR2/(rad*rad)) * restoreDuration; if( *resval < 0.0f ) *resval = resTime; else *resval = max( (*resval), resTime ); } } } // fetch the pieces float pieceRestoreTime; if( noRestore ) { pieceRestoreTime = t + 1.0e9f; } else { pieceRestoreTime = t + restoreAfter + restoreDuration; } // TODO: optimize, right now linear search! int n = mWall2D.getPieceCount(); for( int i = 0; i < n; ++i ) { const CWallPiece2D& p = mWall2D.getPiece( i ); SVector2 c = p.getAABB().getCenter(); SVector3 tocenter = locPos - SVector3(c.x,c.y,0); if( tocenter.lengthSq() < radius*radius ) { mPieceRestoreTimes[i] = pieceRestoreTime; if( mFracturedPieces[i] ) continue; pcs.push_back( i ); fractureOutPiece( i ); } } }
void traceBorder( const TWallVertexVector& vb, TIntVector& polygon, TIntVector& ib ) { static int traceID = 0; ++traceID; int idx0 = getBorderIndex(); assert( idx0 >= 0 && idx0 < vertexTypes.size() ); ib.resize( 0 ); polygon.resize( 0 ); polygon.reserve( vertices.size()/2 ); TIntVector localPolygon; localPolygon.reserve( 128 ); TIntVector localIB; localIB.reserve( 128 ); int idxPrev = idx0; int idx = idx0; int debugCounter = 0; int debugLoopCounter = 0; do { localIB.resize( 0 ); bool willFormLoop; do{ localPolygon.push_back( idx ); borderVertices.erase( idx ); vertexTraceID[idx] = traceID; assert( ++debugCounter <= vertices.size()*2 ); // Next vertex is the neighbor of current, that is not interior // and that is not the previous one. // When there are many possible ones, trace based on angle. int idxNext = -1; SVector2 prevToCurr = vb[idx] - vb[idxPrev]; if( prevToCurr.lengthSq() < 1.0e-6f ) prevToCurr.set( -0.01f, -0.01f ); TIntIntsMap::const_iterator it; it = vertexNexts.find( idx ); assert( it != vertexNexts.end() ); const TIntVector& vnext = it->second; int n = vnext.size(); float bestAngle = 100.0f; for( int i = 0; i < n; ++i ) { int idx1 = vnext[i]; if( idx1 != idxPrev && vertexTypes[idx1] != VTYPE_INTERIOR ) { //if( idx1 != idxPrev ) { SVector2 currToNext = vb[idx1] - vb[idx]; float ang = signedAngle2D( prevToCurr, currToNext ); if( ang < bestAngle ) { bestAngle = ang; idxNext = idx1; } } } assert( bestAngle > -4.0f && bestAngle < 4.0f ); assert( idxNext >= 0 ); willFormLoop = (vertexTraceID[idxNext] == traceID); // Optimization: if best angle is zero, then we're walking // in a straight line. Optimize out the current vertex. if( bestAngle == 0.0f && idx != idx0 && !willFormLoop ) { localPolygon.pop_back(); } idxPrev = idx; idx = idxNext; } while( !willFormLoop ); assert( localPolygon.size() >= 3 ); //if( localPolygon.size() < 3 ) { // return; //} assert( ++debugLoopCounter < vertices.size() ); if( idx == idx0 ) { // The polygon is simple or we found the last loop. // Triangulate local and append to results. triangulator::process( vb, localPolygon, localIB ); polygon.insert( polygon.end(), localPolygon.begin(), localPolygon.end() ); ib.insert( ib.end(), localIB.begin(), localIB.end() ); // We can have separated other loops. Try fetching them as well. idx0 = getBorderIndex(); if( idx0 == -1 ) { return; } else { localPolygon.resize( 0 ); idxPrev = idx0; idx = idx0; } } else { // The polygon must be complex, and we just found a closed loop. // Take only the loop, triangulate it, append to results, continue. TIntVector::const_iterator itLoopStart = std::find( localPolygon.begin(), localPolygon.end(), idx ); assert( itLoopStart != localPolygon.end() ); // append to results TIntVector loopPolygon( itLoopStart, localPolygon.end() ); triangulator::process( vb, loopPolygon, localIB ); polygon.insert( polygon.end(), loopPolygon.begin(), loopPolygon.end() ); ib.insert( ib.end(), localIB.begin(), localIB.end() ); // continue - remove the looped polygon from local localPolygon.resize( itLoopStart - localPolygon.begin() ); } } while( true ); }