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]); }
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; }
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; }
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"; } }
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; }
// [[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); }
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; }
/** * @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; }
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; }
// 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; }
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; }
// ************************************************************************** // 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; }
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; }
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; }
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; }
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; }
/* 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; }
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]; }
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(); }
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; }
// 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; }