Пример #1
2
 void DenseMatImpl::myAddRowMul(long i1, long i2, ConstRefRingElem c)
 {
   const char* const FnName = "DenseMatImpl::myAddRowMul";
   myCheckRowIndex(i1, FnName);
   myCheckRowIndex(i2, FnName);
   if (owner(c) != myR)
     CoCoA_ERROR(ERR::MixedRings, FnName);
   if (IsZero(c)) return;
   const long ncols = myNumCols();
   vector<RingElem> ans(ncols, zero(myR));
   for (long j = 0; j < ncols; ++j)
   {
     myR->myAssign(raw(ans[j]),myEntries[i1][j]);
     if (!myR->myIsZero(myEntries[i2][j]))
       myR->myIsZeroAddMul(raw(ans[j]), raw(c), myEntries[i2][j]);
   }
   // Answer successfully computed in ans, swap it into the i-th row
   for (long j = 0; j < ncols; ++j)
     myR->mySwap(raw(ans[j]), myEntries[i1][j]);
 }
Пример #2
0
bool RandomPrime::FermatsLittleTest()
{ //If true then we have a prime!
	BigInt arr[5] { 2, 3, 5, 7, 11 }; //These are the A's I have chosen
	if (num < 12) 
	{
		//Need this check to compare to our A's
		if ((num == 2) || (num == 3) || (num == 5) || (num == 7) || (num == 11))
		{
			return true;
		}
	}
	for (int i = 0; i < 5; i++) //Change this loop to test less A's if time is taking too long!
	{							//Works like a charm for i < 2
		BigInt ans(num.modExp(arr[i], num - 1, num));
		if (ans != 1) {
			return false;
		}
	}
	return true;
}
bool dlx(int k)  {
    if(R[head]==head) { //È«²¿ÌîÍê
        ans();
        return true;
    }
    int s=INF,c; //ÕÒ1×îÉÙµÄÁжÔÓ¦µÄµÚÒ»¸ö1µÄλÖÃi
    for(int i=R[head];i!=head;i=R[i])
        if(S[i]<s) s=S[i],c=i;

    remove(c); //ɾ³ýc¶ÔÓ¦µÄÁÐ
    for(int i=D[c];i!=c;i=D[i]) {
        int x = to[row[i]][0] , y = to[row[i]][1], z = to[row[i]][2];
        sudoku[x][y] = z;
        for(int j=R[i];j!=i;j=R[j]) remove(C[j]); //ɾ³ýÄÇÒ»ÐÐÓÐ1µÄÁÐ
        if(dlx(k+1)) return true;
        for(int j=L[i];j!=i;j=L[j]) resume(C[j]); //»Ö¸´ÄÇÒ»ÐÐÓÐ1µÄÁÐ
    }
    resume(c); //»Ö¸´c¶ÔÓ¦µÄÁÐ
    return false;
}
Пример #4
0
int main() {

    int t;
    scanf("%d\n", &t);
    while(t--) {
        std::string s;
        getline(std::cin, s);
        std::string ans("");
        ans = ans + s[0];
        for(long p = 1; p < s.size(); p++) {
            if(s[p - 1] != s[p]) {
                ans = ans + s[p];
            }
        }

        std::cout << ans << std::endl;
    }

    return 0;
}
Пример #5
0
    string multiply(string num1, string num2) {
        string ans(num1.size() + num2.size(), '0');

        for (int i = num1.size()-1; i >= 0; --i) {
            int carry = 0;
            for (int j = num2.size()-1; j >= 0; --j) {
                int temp = (ans[i+j+1]- '0') + (num1[i] - '0') * (num2[j] - '0') + carry;
                ans[i+j+1] = temp % 10 + '0';
                carry = temp / 10;
            }
            ans[i] += carry;
        }

        auto iter = ans.find_first_not_of("0");
        if (iter != string::npos) {
            return ans.substr(iter);
        } else {
            return "0";
        }
    }
Пример #6
0
BoolVector BoolVector::operator&(const BoolVector a) const
{
    BoolVector ans(max(this->n, a.n));
    for (int i = this->n, j = a.n, k = max(this->n, a.n); i >= 0 || j >= 0; k--)
    {
        if (i >=0 && j >= 0)
        {
            ans.body[k] = this->body[i] & a.body[j];
        }
        else
        {
            ans.body[k] = 0;         // (this->body[i] & 0) = (a.body[i] & 0) = 0
        }

        i--;
        j--;
    }
    ans.update();
    return ans;
}
 vector<int> findDiagonalOrder(vector<vector<int>>& matrix) {
     int n = matrix.size();
     if(n == 0) return vector<int>();
     int m = matrix[0].size();
     int i = 0, j = 0, count = 0;
     int v = -1;
     int maxC = n*m;
     vector<int> ans( maxC,0);
     while(count < maxC){
         ans[count++] = matrix[i][j];
         i += v;
         j -= v;
         if(j < 0){
             if(i == n){
                 i--;
                 j = 1;
             }else{
                 j = 0;   
             }
             v = -v;
         }else if(i < 0){
             if(j == m){
                 j--;
                 i = 1;
             }else{
                 i = 0;
             }
             v = -v;
         }else if(j == m){
             j = m-1;
             i +=2;
             v = -v;
         }else if(i == n){
             i = n-1;
             j += 2;
             v = -v;
         }
         
     }
     return ans;
 }
main() {
	int n, a, b, i, j, k;
	char s[11];
	while(scanf("%d", &n) == 1) {	
		for(a = 0; a < n; a++)
			for(b = 0; b < n; b++)
				A.t[a][b] = 0, In.t[a][b] = 0,
				init.t[a][b] = 0;
		for(a = 0; a < n; a++) In.t[a][a] = 1;
		
		for(a = 0; a < n; a++) {
			scanf("%s", s);
			for(b = 0; b < n; b++)
				A.t[a][b] = s[b] - '0';
		}
		scanf("%d %d %d", &i, &j, &k);
		printf("%d\n", ans(k+1, i, j, n));
		Floyd_Warshall(n);
	}
	return 0;
}
Пример #9
0
// [[Rcpp::export]]
Rcpp::NumericVector CALLINIT(Rcpp::NumericVector Nparam, Rcpp::NumericVector Ninit, SEXP xifun) {

  Rodeproblem *prob = new Rodeproblem(Nparam,Ninit);

  int i=0;
  int neq = prob->neq();

  prob->Rodeproblem::init_fun(xifun);

  Rcpp::NumericVector ans(neq);

  double time =0;
  prob->time(0);
  prob->evid(0);

  prob->init_call(time);

  for(i=0; i < neq; i++) ans[i] = prob->init(i);
  delete prob;
  return(ans);
}
Пример #10
0
 vector<vector<int>> generateMatrix(int n) {
     vector<vector<int>> ans(n, vector<int>(n, 0));
     int k = 1;
     int s = 0, e = n - 1;
     while(s <= e)
     {
         for(int j = s; j <= e; j++)
             ans[s][j] = k++;
         if(e - s > 0)  // More than one row
             for(int i = s + 1; i <= e; i++)
                 ans[i][e] = k++;
         if(e - s > 0)  // More than one col
             for(int j = e - 1; j >= s; j--)
                 ans[e][j] = k++;
         if(e - s > 1)
             for(int i = e - 1; i >= s + 1; i--)
                 ans[i][s] = k++;
         s++, e--;
     }
     return ans;
 }
Пример #11
0
 /**
  * @param hashTable: A list of The first node of linked list
  * @return: A list of The first node of linked list which have twice size
  */    
 vector<ListNode*> rehashing(vector<ListNode*> hashTable) {
     // write your code here
     int n = hashTable.size();
     if(n == 0) return {};
     int m = n*2;
     vector<ListNode*> ans(m, NULL), tail(m, NULL);
     for(ListNode* h:hashTable) {
         while(h) {
             ListNode* t = h->next;
             h->next = NULL;
             int a = (h->val%m+m)%m;
             if(tail[a] == NULL) ans[a] = tail[a] = h;
             else {
                 tail[a]->next = h;
                 tail[a] = h;
             }
             h = t;
         }
     }
     return ans;
 }
Пример #12
0
int main(){

    const ll MOD = 1e9 + 7;

    ll n; scanf("%lld", &n);
    std::vector<ll> fact(2 * n + 1, 1);
    for(ll p = 2; p <= 2 * n; p++){fact[p] = p * fact[p - 1] % MOD;}

    std::vector<ll> modInv(n + 2, 1);
    for(ll p = 2; p <= n + 1; p++){modInv[p] = (MOD - ((MOD / p) * modInv[MOD % p] % MOD)) % MOD;}

    ll cur(1), ans(0);
    for(ll k = 1; k <= n + 1; k++){
        cur *= ((n + k) * modInv[k] % MOD); cur %= MOD;
        ans += cur; ans %= MOD;
    }

    printf("%lld\n", ans);

    return 0;
}
Пример #13
0
// Calculate the histogram.
cv::Mat ReidDescriptor::whistcY(cv::Mat raster, cv::Mat Weight, int bins)
{
	int M;
	M = raster.cols;
	cv::Mat ans(bins, 1, CV_32F, cv::Scalar(0));

	vector<float> EDGESpt(bins);
	for (int i = 0 ; i < bins ; i++) {
		EDGESpt[i] = i * 1.0 / (bins - 1);
	}

	for (int i = 0; i < M; i++){
		for (int c = 0; c < bins; c++){
			if ((c == bins - 1) || (raster.at<float>(i) < EDGESpt[c + 1] && raster.at<float>(i) >= EDGESpt[c])){
				ans.at<float>(c) += Weight.at<float>(i);
				break;
			}
		}
	}
	return ans;
}
Пример #14
0
vector<int> manacher(const string& s) {
    string s2 = "#";
    for(unsigned int i = 0; i < s.size(); i++)
        s2 += s[i], s2 += '#';

    int c = 1, sz = (int)s2.size(), j;
    vector<int> ans(sz);
    while(c < sz) {
        while(c > ans[c] && c+ans[c]+1 < sz && s2[c-ans[c]-1] == s2[c+ans[c]+1])
            ans[c]++;

        j = 1;
        while(c+j < sz && j < ans[c]-ans[c-j])
            ans[c+j] = ans[c-j], j++;
        if(c+j < sz)
            ans[c+j] = ans[c]-j;
        c += j;
    }

    return ans;
}
Vec RQR_Multiply(const VECTOR &v,
                 const SparseKalmanMatrix &RQR,
                 const SparseVector &Z,
                 double H) {
    int state_dim = Z.size();
    if(v.size() != state_dim + 2) {
        report_error("wrong sizes in RQR_Multiply");
    }
    // Partition v = [eta, epsilon, 0]
    ConstVectorView eta(v, 0, state_dim);
    double epsilon = v[state_dim];

    // Partition this
    Vec RQRZ = RQR * Z.dense();
    double ZRQRZ_plus_H = Z.dot(RQRZ) + H;

    Vec ans(v.size());
    VectorView(ans, 0, state_dim) = (RQR * eta).axpy(RQRZ, epsilon);
    ans[state_dim] = RQRZ.dot(eta) + ZRQRZ_plus_H * epsilon;
    return ans;
}
Пример #16
0
// **************************************************************************
// Member function Inverse()
// PURPOSE: solve inverse matrix.
// **************************************************************************
MatrixMy MatrixMy::Inverse()
{
  MatrixMy temp(row, column);
  MatrixMy ans(row, column);
  MatrixMy col(row, 1);
  MatrixMy indx(row, 1);
  double d;
  int i, j, n = row; 
  
  if (row == column) {
    
    // copy matrix elements' value to temporal matrix
    for (i = 0; i < n; i++) {
      for (j = 0; j < n; j++) {
        temp.m[i][j] = m[i][j];
      }
    }

    temp.LU_Decomposition(indx, d);

    for (j = 0; j < n; j++) {
      for (i = 0; i < n; i++) {
        col.m[i][0] = 0.0;
      }
      col.m[j][0] = 1.0;

      temp.LU_Backsubstitution(indx, col);

      for (i = 0; i < n; i++) {
        ans.m[i][j] = col.m[i][0];
      }
    }
  }
  else {
    printf("ERROR: Matrix Dimension Not Match(Inverse)\n");
  }

  return (ans);

} // End of Inverse()
 /**
  * @param A: Given an integers array A
  * @return: A long long array B and B[i]= A[0] * ... * A[i-1] * A[i+1] * ... * A[n-1]
  */
 vector<long long> productExcludeItself(vector<int> &nums) {
     // write your code here
     int size = nums.size();
     if (size < 2) {             // why size == 1 returns [1] ?
         vector<long long> ans;
         if (size == 1) {         
             ans.push_back(1);
         }
         return ans;
     }
     vector<long long> left(size, 0);
     vector<long long> right(size, 0);
     
     for (int i = 0; i < nums.size(); i++) {
         if (i == 0) {
             left[i] = nums[i];
         } else {
             left[i] = left[i - 1] * nums[i];
         }
     }
     for (int i = size - 1; i >= 0; i--) {
         if (i == size - 1) {
             right[i] = nums[i];
         } else {
             right[i] = right[i + 1] * nums[i];
         }
     }
     
     vector<long long> ans (size, 0);
     for (int i = 0; i < size; i++) {
         if (i == 0) {
             ans[i] = right[i + 1];
         } else if (i == size - 1) {
             ans[i] = left[i - 1];
         } else {
             ans[i] = left[i - 1] * right[i + 1];
         }
     }
     return ans;
 }
Пример #18
0
 vector<int> subarraySumClosest(vector<int> nums)
 {
     using PIS = pair<int, size_t>;
     vector<PIS> vec(nums.size());
     int sum = 0;
     for (size_t i = 0; i < nums.size(); ++i)
         vec[i] = {sum += nums[i], i};
     
     sort(vec.begin(), vec.end(), [](const PIS &a, const PIS &b){return a.first < b.first;});
     
     int closest = abs(nums[0]);
     vector<int> ans(2);
     for (size_t i = 1; i < vec.size(); ++i)
         if (abs(vec[i].first - vec[i - 1].first) < closest)
         {
             closest = abs(vec[i].first - vec[i - 1].first);
             ans[0] = min(vec[i].second, vec[i - 1].second) + 1;
             ans[1] = max(vec[i].second, vec[i - 1].second);
         }
             
     return ans;
 }
Пример #19
0
 PointProcess HomogeneousPoissonProcess::simulate(
     const DateTime &t0,
     const DateTime &t1,
     boost::function<Data*()> mark_generator)const{
   PointProcess ans(t0, t1);
   int number_of_events = rpois(expected_number_of_events(t0, t1));
   double duration = t1 - t0;
   std::vector<double> points(number_of_events);
   for(int i = 0; i < number_of_events; ++i){
     points[i] = runif(0, duration);
   }
   std::sort(points.begin(), points.end());
   for(int i = 0; i < number_of_events; ++i){
     Data *mark = mark_generator();
     if (mark) {
       ans.add_event(t0 + points[i], Ptr<Data>(mark));
     } else {
       ans.add_event(t0 + points[i]);
     }
   }
   return ans;
 }
Пример #20
0
NLargeInteger NNormalSurfaceVectorANStandard::edgeWeight(
        size_t edgeIndex, const NTriangulation* triang) const {
    // Find a tetrahedron next to the edge in question.
    const NEdgeEmbedding& emb = triang->edge(edgeIndex)->front();
    long tetIndex = emb.tetrahedron()->index();
    int start = emb.vertices()[0];
    int end = emb.vertices()[1];

    // Add up the triangles, quads and octagons meeting that edge.
    // Triangles:
    NLargeInteger ans((*this)[10 * tetIndex + start]);
    ans += (*this)[10 * tetIndex + end];
    // Quads:
    ans += (*this)[10 * tetIndex + 4 + quadMeeting[start][end][0]];
    ans += (*this)[10 * tetIndex + 4 + quadMeeting[start][end][1]];
    // Octagons:
    ans += (*this)[10 * tetIndex + 7];
    ans += (*this)[10 * tetIndex + 8];
    ans += (*this)[10 * tetIndex + 9];
    ans += (*this)[10 * tetIndex + 7 + quadSeparating[start][end]];
    return ans;
}
Пример #21
0
BoolVector BoolVector::operator~() const
{
    BoolVector ans(this->n);
    for (int i = 0; i < this->n; i++)
    {
        ans.body[i] = ~ this->body[i];
    }
    ans.update();
    if ((*this).length % 32)
    {
        unsigned int bit_mask = 0;
        for (int i = 0; i < 32 - ((*this).length % 32); i++)
        {
            bit_mask <<= 1;
            bit_mask++;
        }
        bit_mask <<= ((*this).length % 32);
        ans.body[this->n - ((*this).length / 32 + 1)] &= ~ bit_mask;
    }
    ans.update();
    return ans;
}
Пример #22
0
/* O(logn) */
vector<int> searchRange_BS(int A[], int n, int target) {
    vector<int> ans(2, -1);
    int left = 0;
    int right = n - 1;
    while (left <= right) {
        int mid = (left + right) / 2;
        if (A[mid] > target) {
            right = mid - 1;
        }
        else if (A[mid] < target) {
            left = mid + 1;
        }
        else {
            ans[0] = 0;
            ans[1] = 0;
            if (A[left] == target) {
                ans[0] = left;
            }
            if (A[right] == target) {
                ans[1] = right;
            }
            for (int i = mid; i <= right + 1; i++) {
                if (A[i] != target) {
                    ans[1] = i - 1;
                    break;
                }
            }
            for (int i = mid; i >= left; i--) {
                if (A[i] != target) {
                    ans[0] = i + 1;
                    break;
                }
            }
            break;
        }
    }
    return ans;
}
Пример #23
0
 vector<vector<int> > combinationSum2(vector<int> &candidates, int target) {
     vector<vector<vector<int> > > ans(1+target);
     
     map<int, int> ct;
     for (int i = 0; i < candidates.size(); ++ i) {
         ++ ct[candidates[i]];
     }        
     
     for (int i = 1; i <= target; ++ i) {
         for (int j = 0; j < candidates.size(); ++ j) {
             if (i == candidates[j]) {
                 vector<int> v(1);
                 v[0] = candidates[j];
                 if (find(ans[i].begin(), ans[i].end(), v) == ans[i].end()) {
                     ans[i].push_back(v);
                     //break; // don't break, since it's possible that, e.g., [4], and [2,2]. if sorted first, then can break.
                 }
             }
             else if (i > candidates[j]) {
                 vector<vector<int> > w = ans[i - candidates[j]];
                 for (int k = 0; k < w.size(); ++ k) {
                     vector<int> v = w[k];
                     if (ct[candidates[j]] == getCt(v, candidates[j])) {
                         continue;
                     }
                     v.push_back(candidates[j]);
                     sort(v.begin(), v.end());
                     if (find(ans[i].begin(), ans[i].end(), v) == ans[i].end()) 
                     {
                         ans[i].push_back(v);
                     }
                 }
             }
         } // end for
     } // end for
     
     return ans[target];
 }
Пример #24
0
 vector<vector<int>> fourSum(vector<int>& nums, int target) {
     sort(nums.begin(), nums.end());
     unordered_map<int, vector<pair<int, int>>> mp;
     
     for(int i = 0; i < nums.size(); ++i){
         for(int j = i + 1; j < nums.size(); ++j){
             mp[nums[i]+nums[j]].push_back(make_pair(i, j));
         }
     }//1+2 2+3 1+4... 2找2
     
     vector<vector<int>> res;//i,j + k,l
     
     for(int i = 0; i < (int)nums.size()-3; ++i){//为什么类型转换?
         if(i && nums[i] == nums[i-1]) continue;//duplicated
         for(int j = i+1; j < (int)nums.size()-2; ++j){
             if(j > i+1 && nums[j] == nums[j-1]) continue;
             int remain = target - nums[i] - nums[j];
             if(mp.find(remain) != mp.end()){
                 for(auto itr = mp[remain].begin(); itr != mp[remain].end(); ++itr){
                     int k = (*itr).first;
                     int l = (*itr).second;
                     
                     if(k > j){
                         vector<int> ans(4);
                         ans[0] = nums[i];
                         ans[1] = nums[j];
                         ans[2] = nums[k];                           
                         ans[3] = nums[l];
                         if(res.empty() || ans != res.back()){
                             res.push_back(ans);
                         }
                     }
                 }
             }
         }
     }
     return res;
 }
 vector<int> productExceptSelf(vector<int>& nums) {
     if (nums.empty())
         return vector<int>();
     vector<int> ans(nums.size(), 1);
     for (int i = nums.size()-1; i >= 0; i--) {
         if (i == nums.size()-1)
             ans[i] = nums[i];
         else
             ans[i] = ans[i+1]*nums[i];
     }
     for (int i=1; i<nums.size(); i++) {
         nums[i] = nums[i-1] * nums[i];
     }
     for (int i = 0; i < ans.size(); i++) {
         if (i == 0)
             ans[i] = ans[i+1];
         else if (i == ans.size()-1)
             ans[i] = nums[i-1];
         else
             ans[i] = nums[i-1]*ans[i+1];
     }
     return ans;
 }
 int FindGreatestSumOfSubArray(vector<int> array) {
     
     if(array.empty())
         return 0;
     
     int retMax=INT_MIN;
     int len = array.size();
     vector<int> ans(len,INT_MIN);
     
     ans[0] = array[0];
     retMax = ans[0];
     
     for(int i=1; i<len; i++)
     {
     	ans[i] = getMax( (ans[i-1] + array[i]), array[i]);  
         
         if(ans[i] > retMax)
             retMax = ans[i];
     }
     
     return retMax;
 
 }
	vector<TreeNode *> dfs(int s, int t) {
		if (s > t) {
			vector<TreeNode *> ans(1, nullptr);
			return ans;
		}

		vector<TreeNode*> ans;
		for (int i = s; i <= t; i ++) {
			vector<TreeNode*> le = dfs(s, i - 1);
			vector<TreeNode*> ri = dfs(i + 1, t);

			for (int j = 0; j < le.size(); j ++) {
				for (int k = 0; k < ri.size(); k ++) {
					TreeNode *cur = new TreeNode(i);
					cur->left = le[j];
					cur->right = ri[k];
					ans.push_back(cur);
				}
			}
		}

		return ans;
	}
void solve_sudoku(){
    init(27*9 + 81);
    int nn = 0;
    for(int i = 0 ; i< 9 ;i++)
        for(int f = 0 ;f < 9;f++)
            for(int g= 0 ; g< 9; g++){
                to[nn][0] = i;
                to[nn][1] = f;
                to[nn][2] = g;
                
                if(-1==sudoku[i][f] || g==sudoku[i][f]){
                    addnode(nn,1+mul(i,g));
                    addnode(nn,82+mul(f,g));
                    addnode(nn,163+ mul( getkuai(i,f),g) );
                    addnode(nn,244+ mul(i,f));
                }
                nn++;
            }
    if(false == dlx(0))
        cout << "impossible" << endl;
    else 
        ans();
}
Пример #29
0
vector<int> Solution::order(vector<int> &heights, vector<int> &infronts) {

    vector< pair<int,int> > v;
    int n=heights.size();
    vector<int> ans(n);

    for(int i=0;i<n;i++){
        v.push_back(make_pair(heights[i],infronts[i]));
    }

    sort(v.begin(),v.end());

    SegTree s(n);

    for(int i=0;i<n;i++){
        int index=s.query(v[i].second+1,0,n-1,0); // where is v[i].second th empty position
        ans[index]=v[i].first;
        //cout<<index<<endl;
        s.update(index,0,0,n-1,0);
    }

    return ans;
}
Пример #30
0
// Returns the polygons that result of cutting the CONVEX
// polygon p by the infinite line that passes through (x0, y0)
// and (x1, y1).
// The returned value has either 1 element if this line
// doesn't cut the polygon at all (or barely touches it)
// or 2 elements if the line does split the polygon.
vector<Polygon> split(const Polygon &p, Double x0, Double y0,
                      Double x1, Double y1) {
    int hits = 0, side = 0;
    Double x, y;
    vector<Polygon> ans(2);
 
    for (int i = 0; i < p.size(); ++i) {
        int j = (i + 1) % p.size();
        if (segment_line_intersection(p[i].x, p[i].y,
            p[j].x, p[j].y,   x0, y0, x1, y1,   x, y)) {
            hits++;
            ans[side].push_back(p[i]);
            if (cmp(p[i].x, x) != 0 or cmp(p[i].y, y) != 0) {
                ans[side].push_back(Point(x, y));
            }
            side ^= 1;
            ans[side].push_back(Point(x, y));
        } else {
            ans[side].push_back(p[i]);
        }
    }
    return hits < 2 ? vector<Polygon>(1, p) : ans;
}