虽然这个队，以后再也没有了，但是他的模板，是永垂不朽的！【误

  1. #include <ext/pb_ds/priority_queue.hpp>
  3. __gnu_pbds::priority_queue < int > Q;
  4. 优先队列，配对堆默认，从小到大!
  6. __gnu_pbds::priority_queue < int , greater < int > , pairing_heap_tag  > Q;
  7. __gnu_pbds::priority_queue < int , greater < int > , pairing_heap_tag  > :: point_iterator id[ maxn ];
  9. id[x] = Q.push( 5 ) ;
  10. Q.modify( id[x] , 6) ; //直接修改
  12. 支持join , push , pop操作
  14. #include <ext/pb_ds/assoc_container.hpp>
  16. using namespace __gnu_pbds;
  18. tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> rbt;
  19. tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> :: iterator it ;
  21. find_by_order(size_type order)
  22. 找第order+1小的元素的迭代器
  24. order_of_key(int val)
  25. 问有多少个比val小
  27. #include <ext/pb_ds/assoc_container.hpp>
  28. #include <ext/pb_ds/hash_policy.hpp>
  30. __gnu_pbds::gp_hash_table < key , value > hs;
  31. 哈希
  32. 支持[]和find操作
  34. 三角形:
  35. 1. 半周长 P=(a+b+c)/2
  36. 2. 面积 S=aHa/2=absin(C)/2=sqrt(P(P-a)(P-b)(P-c))
  37. 3. 中线 Ma=sqrt(2(b^2+c^2)-a^2)/2=sqrt(b^2+c^2+2bccos(A))/2
  38. 4. 角平分线 Ta=sqrt(bc((b+c)^2-a^2))/(b+c)=2bccos(A/2)/(b+c)
  39. 5. 高线 Ha=bsin(C)=csin(B)=sqrt(b^2-((a^2+b^2-c^2)/(2a))^2)
  40. 6. 内切圆半径 r=S/P=asin(B/2)sin(C/2)/sin((B+C)/2)
  41.                =4Rsin(A/2)sin(B/2)sin(C/2)=sqrt((P-a)(P-b)(P-c)/P)
  42.                =Ptan(A/2)tan(B/2)tan(C/2)
  43. 7. 外接圆半径 R=abc/(4S)=a/(2sin(A))=b/(2sin(B))=c/(2sin(C))
  45. 四边形:
  46. D1,D2为对角线,M对角线中点连线,A为对角线夹角
  47. 1. a^2+b^2+c^2+d^2=D1^2+D2^2+4M^2
  48. 2. S=D1D2sin(A)/2
  49. (以下对圆的内接四边形)
  50. 3. ac+bd=D1D2
  51. 4. S=sqrt((P-a)(P-b)(P-c)(P-d)),P为半周长
  53. 正n边形:
  54. R为外接圆半径,r为内切圆半径
  55. 1. 中心角 A=2PI/n
  56. 2. 内角 C=(n-2)PI/n
  57. 3. 边长 a=2sqrt(R^2-r^2)=2Rsin(A/2)=2rtan(A/2)
  58. 4. 面积 S=nar/2=nr^2tan(A/2)=nR^2sin(A)/2=na^2/(4tan(A/2))
  60. 圆:
  61. 1. 弧长 l=rA
  62. 2. 弦长 a=2sqrt(2hr-h^2)=2rsin(A/2)
  63. 3. 弓形高 h=r-sqrt(r^2-a^2/4)=r(1-cos(A/2))=atan(A/4)/2
  64. 4. 扇形面积 S1=rl/2=r^2A/2
  65. 5. 弓形面积 S2=(rl-a(r-h))/2=r^2(A-sin(A))/2
  67. 棱柱:
  68. 1. 体积 V=Ah,A为底面积,h为高
  69. 2. 侧面积 S=lp,l为棱长,p为直截面周长
  70. 3. 全面积 T=S+2A
  72. 棱锥:
  73. 1. 体积 V=Ah/3,A为底面积,h为高
  74. (以下对正棱锥)
  75. 2. 侧面积 S=lp/2,l为斜高,p为底面周长
  76. 3. 全面积 T=S+A
  78. 棱台:
  79. 1. 体积 V=(A1+A2+sqrt(A1A2))h/3,A1.A2为上下底面积,h为高
  80. (以下为正棱台)
  81. 2. 侧面积 S=(p1+p2)l/2,p1.p2为上下底面周长,l为斜高
  82. 3. 全面积 T=S+A1+A2
  84. 圆柱:
  85. 1. 侧面积 S=2PIrh
  86. 2. 全面积 T=2PIr(h+r)
  87. 3. 体积 V=PIr^2h
  89. 圆锥:
  90. 1. 母线 l=sqrt(h^2+r^2)
  91. 2. 侧面积 S=PIrl
  92. 3. 全面积 T=PIr(l+r)
  93. 4. 体积 V=PIr^2h/3
  95. 圆台:
  96. 1. 母线 l=sqrt(h^2+(r1-r2)^2)
  97. 2. 侧面积 S=PI(r1+r2)l
  98. 3. 全面积 T=PIr1(l+r1)+PIr2(l+r2)
  99. 4. 体积 V=PI(r1^2+r2^2+r1r2)h/3
  101. 球:
  102. 1. 全面积 T=4PIr^2
  103. 2. 体积 V=4PIr^3/3
  105. 球台:
  106. 1. 侧面积 S=2PIrh
  107. 2. 全面积 T=PI(2rh+r1^2+r2^2)
  108. 3. 体积 V=PIh(3(r1^2+r2^2)+h^2)/6
  110. 球扇形:
  111. 1. 全面积 T=PIr(2h+r0),h为球冠高,r0为球冠底面半径
  112. 2. 体积 V=2PIr^2h/3
  114. 从左边的未匹配点开始进行BFS，对于左边的点，依次检查所有向连的点并加入BFS（判断是否加过），右边的点只能走匹配边，然后对访问到的点进行标记，取左边没被标记的，右边标记了的
  116. 如果一个图是二分图，那么它的最大独立集就是多项式时间可以解决的问题了 |最大独立集| = |V|-|最大匹配数|
  118. 二分图的最大团 = 补图的最大独立集
  120. 先做一次最大匹配 然后对于已经匹配的点 如果他存在与之相连 但是不是被匹配的点 那么他总是在最小覆盖集里面
  122. 1.给一张图，问有多少条边肯定在 MST 上？
  123.  对所有边排序,每次扫出权值相同的边,然后跑tarjan_dcc(求割边),有多少条割边，表示对答案的贡献就是多少，之后将这些边的两边点进行缩点(并查集维护)
  124.    for(int i = 0 ; i < m ; ++ i)
  125. {
  126.     int base = e[i].w;
  127.     for(int j = i + 1 ; j < m ; ++ j){
  128.           //扫描相同权值的边
  129.           //进行tarjan_dcc算法
  130.           //合并
  131.      }
  132. }
  134. 2.给一张图，问有多少条边可能在 MST 上？
  135.  对所有边排序，每次新加入一条边之后，向后扫描所有相同权值的边，如果有边也可以合并两端，则打上标记
  136.     for(int i = 0 ; i < m ; ++ i)
  137.    {
  138.       if (find_set(e[i].u) == find_set(e[i].v) ) continue;
  139.       int a1 = find_set(e[i].u) ,a2 = find_set(e[i].v);
  140.       if (a1 > a2)
  141.        swap(a1,a2);
  142.       for(int j = i + 1 ; j < m ; ++ j)
  143.        {
  144.           if (e[j].w != e[i].w ) break;
  145.           int b1 = find_set(e[j].u) , b2 =find_set(e[j].v);
  146.           if (b1 > b2)
  147.            swap(b1,b2);
  148.           if ( a1 == b1 && a2 == b2)
  149.             flag[j] = 1;
  150.        }
  151.       union_set(e[i].u ,e[i].v);
  152.       flag[i] = 1;
  153.    }
  155. 3.可以一次dfs用n^2的时间预处理出树上任意两点的某个属性，用dp做
  156.   dfs(int u)
  157. {
  158.    vis[u] = 1;
  159.    for(int i = head[u] ; ~i ; i =e[i].nxt)
  160. {
  161.    int v = e[i].v;
  162.    for(int j = 1 ; j <= n ; ++ j)
  163.     if(vis[j])
  164.      更新dp
  165. }
  166. }
  168. KM算法
  169. const int maxn = 300 ;
  170. const int inf = 1e9;
  171. int mat[maxn + 1][maxn + 1] , N ;
  172. int lx[maxn + 1];
  173. int ly[maxn + 1];
  174. int slack[maxn + 1];
  175. int S[maxn + 1];
  176. int T[maxn + 1];
  177. int lft[maxn + 1];
  178. bool dfs( int x ){
  179.     S[x] = 1;
  180.     for(int i = 1 ; i <= N ; ++ i)
  181.         if( !T[i] ){
  182.             int gap = lx[x] + ly[i] - mat[x][i];
  183.             if( gap == 0 ){
  184.                 T[i] = 1;
  185.                 if( lft[i] == 0 || dfs( lft[i] ) ){
  186.                     lft[i] = x;
  187.                     return true;
  188.                 }
  189.             }else slack[i] = min( slack[i] , gap );
  190.         }
  191.     return false;
  192. }
  194. int solve(){
  196.     for(int i = 1 ; i <= N ; ++ i){
  197.         lx[i] = ly[i] = lft[i] = 0;
  198.         for(int j = 1 ; j <= N ; ++ j) lx[i] = max( lx[i] , mat[i][j] );
  199.     }
  201.     for(int i = 1 ; i <= N ; ++ i){
  202.         while( 1 ){
  203.             for(int j = 1 ; j <= N ; ++ j) slack[j] = inf , S[j] = T[j] = 0;
  204.             if( dfs( i ) ) break;
  205.             int d = inf;
  206.             for(int j = 1 ; j <= N ; ++ j) if( !T[j] ) d = min( d , slack[j] );
  207.             for(int j = 1 ; j <= N ; ++ j){
  208.                 if( S[j] ) lx[j] -= d;
  209.                 if( T[j] ) ly[j] += d;
  210.             }
  211.         }
  212.     }
  213.     int res = 0;
  214.     for(int i = 1 ; i <= N ; ++ i) res += lx[i] + ly[i];
  215.     return res;
  216. }
  218. Tarjan_bcc
  219. int tarjan_dfs(int u,int fa)
  220. {
  221.     dfn[u] = low[u] = ++T;
  222.     for(int i = head[u] ; ~i ; i = e[i].nxt)
  223.     {
  224.         int v = e[i].v;
  225.         if(v == fa) continue;
  226.         if(!dfn[v])
  227.         {
  228.             s.push(make_pair(u,v));
  229.             int lowv = tarjan_dfs(v,u);
  230.             low[u] = min(low[u],lowv);
  231.             if(lowv >= dfn[u])
  232.             {
  233.                 bcc_cnt++;bcc[bcc_cnt].clear();
  234.                 while(1)
  235.                 {
  236.                     dl ss = s.top();s.pop();
  237.                     int x = ss.first , y = ss.second;
  238.                     if(belong[x] != bcc_cnt)
  239.                     {
  240.                         bcc[bcc_cnt].push_back(x);
  241.                         belong[x] = bcc_cnt;
  242.                     }
  243.                     if(belong[y] != bcc_cnt)
  244.                     {
  245.                         bcc[bcc_cnt].push_back(y);
  246.                         belong[y] = bcc_cnt;
  247.                     }
  248.                     if(x==u&&y==v) break;
  249.                 }
  250.             }
  251.         }
  252.         else if(dfn[v] < dfn[u])
  253.         {
  254.             s.push(make_pair(u,v));
  255.             low[u] = min(low[u] , dfn[v]);
  256.         }
  257.     }
  258.     return low[u];
  259. }
  261. 辛普森积分
  262. double F(double x){ return exp(-x*x/2); }
  263. double simpson( double a , double b ){
  264.     double c = a + (  b - a ) / 2;
  265.     return (F(a) + 4*F(c) + F(b))*(b-a) / 6;
  266. }
  267. double asr( double a , double b , double eps , double A){
  268.     double c = a + ( b - a ) / 2;
  269.     double L = simpson( a , c ) , R = simpson( c , b );
  270.     if(fabs(L+R-A) <= 15*eps) return L + R + (L+R-A)/15.0;
  271.     return asr( a , c , eps / 2 , L ) + asr( c , b , eps / 2 , R);
  272. }
  273. double asr( double a , double b , double eps ){
  274.     return asr( a , b , eps , simpson( a , b ) );
  275. }
  277. Xor为K的方案数
  278. int n , p[maxn] , dp[maxn][2] , dp2[maxn][2]  , target ;
  279. int solve( int target ){
  280.     int rs = 0 , bit ;
  281.     for(bit = 30 ; bit >= 0 ; -- bit){
  282.         memset( dp , 0 , sizeof( dp ) );
  283.         memset( dp2 , 0 , sizeof( dp2 ) );
  284.         dp[0][0] = dp2[n + 1][0] = 1;
  285.         for(int i = 0 ; i < n ; ++ i) for(int f = 0 ; f < 2 ; ++ f) if( dp[i][f] ){
  286.             if( p[i + 1] >> bit & 1 ){
  287.                 up( dp[i + 1][f ^ 1] , mul( dp[i][f] , (p[i + 1]&((1<<bit)-1))+1 ));
  288.                 up( dp[i + 1][f] , mul( dp[i][f] , 1 << bit ) );
  289.             }else up( dp[i + 1][f] , mul( dp[i][f] , (p[i + 1]&((1<<bit)-1))+1 ));
  290.         }
  291.         for(int i = n + 1 ; i > 1 ; -- i) for(int f = 0 ; f < 2 ; ++ f) if( dp2[i][f] ){
  292.             if( p[i - 1] >> bit & 1 ) up( dp2[i - 1][f ^ 1] , mul( dp2[i][f] , (p[i - 1]&((1<<bit)-1))+1 ));
  293.             else up( dp2[i - 1][f] , mul( dp2[i][f] , (p[i - 1]&((1<<bit)-1))+1 ));
  294.         }
  295.         int pre = 0 ;
  296.         for(int i = n; i >= 1 ; -- i){
  297.             if( p[i] >> bit & 1 ) for(int j = 0 ; j < 2 ; ++ j) up( rs , mul( dp[i - 1][j] , dp2[i + 1][ (target >> bit & 1) ^ j ] ) );
  298.             pre ^= ( p[i] >> bit & 1 );
  299.         }
  300.         if( pre != ( target >> bit & 1 ) ) break;
  301.     }
  302.     return rs + (bit == -1);
  303. }
  305. 1e9内素数和
  306. long long dp[maxn][105];
  307. int vis[maxn * 100] , tot , prime[maxn * 100] ;
  309. int cal(long long x){
  310.     int l = 0 , r = tot - 1;
  311.     while(l <= r){
  312.         int mid = l + ( (r-l) >> 1);
  313.         if( 1LL * (long long)prime[mid] * prime[mid] <= x) l = mid + 1;
  314.         else r = mid - 1;
  315.     }
  316.     return prime[l-1];
  317. }
  319. long long dfs(int x , int y){
  320.     if(y <= 1) return ( 1LL * (x + 2) * (x - 1) ) >> 1LL; //边界条件
  321.     int flag = ( x <= 1e4 && y <= 1e2);
  322.     if( 1LL * y * y > x) return dfs( x , cal(x)); //find
  323.     if( vis[y] ) return dfs( x , prime[upper_bound(prime , prime + tot , y ) - prime - 1] );
  324.     if(flag && ~dp[x][y]) return dp[x][y];
  325.     long long ans = 0;
  326.     ans = dfs( x , y - 1 ) - 1LL * y * ( dfs(x / y , y - 1 ) - dfs( y - 1 , cal( y - 1 )) );
  327.     if(flag) dp[x][y] = ans;
  328.     return ans;
  329. }
  331. void init(){
  332.     for(int i = 2 ; i <= 1e6 ; ++ i)
  333.     if(!vis[i]){
  334.         prime[tot++] = i;
  335.         for(int j = i * 2 ; j <= 1e6 ; j += i) vis[j] = 1;
  336.     }
  337. }
  339. 快速求第一类斯特林数
  340. int seq[60][maxn << 1] , ptr = 0;
  341. long long B[maxn << 1] , C[maxn << 1];
  343. int DFS( int l , int r ){
  344.     if( l == r ){
  345.         int id = ptr ++ ;
  346.         seq[id][1] = l ;
  347.         seq[id][0] = 1 ;
  348.         return id;
  349.     }else{
  350.         int mid = l + r >> 1;
  351.         int lid = DFS( l , mid );
  352.         int rid = DFS( mid + 1 , r );
  353.         ptr -= 2;
  354.         int newid = ptr ++ ;
  355.         int len = 1;
  356.         while( len <= r - l + 1 ) len <<= 1;
  357.         for(int i = 0 ; i < len ; ++ i) B[i] = seq[lid][i] , C[i] = seq[rid][i] , seq[lid][i] = seq[rid][i] = 0;
  358.         NTT( B , len , 1 );
  359.         NTT( C , len , 1 );
  360.         for(int i = 0 ; i < len ; ++ i) B[i] = B[i] * C[i] % Mod;
  361.         NTT( B , len , -1 );
  362.         for(int i = 0 ; i < len ; ++ i) seq[newid][i] = B[i];
  363.         return newid;
  364.     }
  365. }
  366. int id = DFS( 0 , N - 1 );
  367. for(int i = N ; i >= 0 ; -- i){
  368.     printf( "f[%d] is %d \n" , N - i , seq[id][i] );
  369. }
  371. FFT
  372. const double PI = acos(-1.0);
  373. //复数结构体
  374. struct Complex
  375. {
  376.     double r,i;
  377.     Complex(double _r = 0.0,double _i = 0.0)
  378.     {
  379.         r = _r; i = _i;
  380.     }
  381.     Complex operator +(const Complex &b)
  382.     {
  383.         return Complex(r+b.r,i+b.i);
  384.     }
  385.     Complex operator -(const Complex &b)
  386.     {
  387.         return Complex(r-b.r,i-b.i);
  388.     }
  389.     Complex operator *(const Complex &b)
  390.     {
  391.         return Complex(r*b.r-i*b.i,r*b.i+i*b.r);
  392.     }
  393. };
  394. /*
  395.  * 进行FFT和IFFT前的反转变换。
  396.  * 位置i和 （i二进制反转后位置）互换
  397.  * len必须去2的幂
  398.  */
  399. void change(Complex y[],int len)
  400. {
  401.     int i,j,k;
  402.     for(i = 1, j = len/2;i < len-1; i++)
  403.     {
  404.         if(i < j)swap(y[i],y[j]);
  405.         //交换互为小标反转的元素，i<j保证交换一次
  406.         //i做正常的+1，j左反转类型的+1,始终保持i和j是反转的
  407.         k = len/2;
  408.         while( j >= k)
  409.         {
  410.             j -= k;
  411.             k /= 2;
  412.         }
  413.         if(j < k) j += k;
  414.     }
  415. }
  416. /*
  417.  * 做FFT
  418.  * len必须为2^k形式，
  419.  * on==1时是DFT，on==-1时是IDFT
  420.  */
  421. void fft(Complex y[],int len,int on)
  422. {
  423.     change(y,len);
  424.     for(int h = 2; h <= len; h <<= 1)
  425.     {
  426.         Complex wn(cos(-on*2*PI/h),sin(-on*2*PI/h));
  427.         for(int j = 0;j < len;j+=h)
  428.         {
  429.             Complex w(1,0);
  430.             for(int k = j;k < j+h/2;k++)
  431.             {
  432.                 Complex u = y[k];
  433.                 Complex t = w*y[k+h/2];
  434.                 y[k] = u+t;
  435.                 y[k+h/2] = u-t;
  436.                 w = w*wn;
  437.             }
  438.         }
  439.     }
  440.     if(on == -1)
  441.         for(int i = 0;i < len;i++)
  442.             y[i].r /= len;
  443. }
  445. FWT
  446. #include <bits/stdc++.h>
  448. using namespace std;
  450. const int N = 1 << 20;
  452. int a[N];
  454. void tfand(int a[], int n) {
  455.     if(n == 1) return;
  456.     int x = n >> 1;
  457.     tfand(a, x); tfand(a + x, x);
  458.     for(int i = 0; i < x; ++ i)
  459.         a[i] += a[i + x];
  460. }
  462. void utfand(long long a[], int n) {
  463.     if(n == 1) return;
  464.     int x = n >> 1;
  465.     for(int i = 0; i < x; ++ i)
  466.         a[i] -= a[i + x];
  467.     utfand(a, x); utfand(a + x, x);
  468. }
  470. void tfor(int a[], int n) {
  471.     if(n == 1) return;
  472.     int x = n >> 1;
  473.     tfor(a, x); tfor(a + x, x);
  474.     for(int i = 0; i < x; ++ i)
  475.         a[i + x] += a[i];
  476. }
  478. void utfor(long long a[], int n) {
  479.     if(n == 1) return;
  480.     int x = n >> 1;
  481.     for(int i = 0; i < x; ++ i)
  482.         a[i + x] -= a[i];
  483.     utfor(a, x); utfor(a + x, x);
  484. }
  486. long long t[N];
  488. void utfxor(long long a[], int n) {
  489.     if(n == 1) return;
  490.     int x = n >> 1;
  491.     for(int i = 0; i < x; ++ i) {
  492.         t[i] = (a[i] + a[i + x]) >> 1;
  493.         t[i + x] = (a[i + x] - a[i]) >> 1;
  494.     }
  495.     memcpy(a, t, n * sizeof(long long));
  496.     utfxor(a, x); utfxor(a + x, x);
  497. }
  499. int tmp[N];
  501. void tfxor(int a[], int n) {
  502.     if(n == 1) return;
  503.     int x = n >> 1;
  504.     tfxor(a, x); tfxor(a + x, x);
  505.     for(int i = 0; i < x; ++ i) {
  506.         tmp[i] = a[i] - a[i + x];
  507.         tmp[i + x] = a[i] + a[i + x];
  508.     }
  509.     memcpy(a, tmp, n * sizeof(int));
  510. }
  512. long long b[N];
  514. int c[N];
  516. NTT
  517. typedef long long ll;
  518. const ll Mod=998244353;   // 模数
  519. const ll SpMul=3;  // 原根
  520. ll qpow(ll a,ll k)
  521. {
  522.     ll res=1LL;
  523.     while(k>0)
  524.     {
  525.         if(k&1)res=res*a%Mod;
  526.         a=a*a%Mod;
  527.         k>>=1;
  528.     }
  529.     return res;
  530. }
  531. void Change(ll y[],int len)
  532. {
  533.     for(int i=1,j=len/2;i<len-1;i++)
  534.     {
  535.         if(i<j)swap(y[i],y[j]);
  536.         int k=len/2;
  537.         while(j>=k)
  538.         {
  539.             j-=k;
  540.             k/=2;
  541.         }
  542.         if(j<k)j+=k;
  543.     }
  544. }
  546. void NTT(ll y[],int len,int on)
  547. {
  548.     Change(y,len);
  549.     for(int h=2;h<=len;h<<=1)
  550.     {
  551.         ll wn=qpow(SpMul,(Mod-1)/h);
  552.         if(on==-1)wn=qpow(wn,Mod-2);
  553.         for(int j=0;j<len;j+=h)
  554.         {
  555.             ll w=1LL;
  556.             for(int k=j;k<j+h/2;k++)
  557.             {
  558.                 ll u=y[k];
  559.                 ll t=w*y[k+h/2]%Mod;
  560.                 y[k]=(u+t)%Mod;
  561.                 y[k+h/2]=(u-t+Mod)%Mod;
  562.                 w=w*wn%Mod;
  563.             }
  564.         }
  565.     }
  566.     if(on==-1)
  567.     {
  568.         ll t=qpow(len,Mod-2);
  569.         for(int i=0;i<len;i++)
  570.             y[i]=y[i]*t%Mod;
  571.     }
  572. }
  574. CRT与Ex_GCD 和 求逆
  575. X / y % p = X % (y*p) / y
  577. void extend_gcd(long long a , long long b , long long& d , long long & x , long long &y )
  578. {
  579.   if (!b)
  580.    {
  581.       d = a;
  582.       x = 1;
  583.       y = 0;
  584.    }
  585.   else
  586.    {
  587.       extend_gcd(b,a%b,d,y,x);
  588.       y -= x*(a/b);
  589.    }
  590. }
  592. long long inv(long long a,long long n)
  593. {
  594.   long long d , x , y;
  595.   extend_gcd(a,n,d,x,y);
  596.   return d==1? (x+n) % n : -1;
  597. }
  599. // n个方程,x=a[i] (mod m[i])  ( 0 <= i < n)
  600. long long CRT(int n ,long long * a , long long * m)
  601. {
  602.     long long M = 1 , d , y , x = 0;
  603.     for(int i = 0 ; i < n ; ++ i) M*=m[i];
  604.     for(int i = 0 ; i < n ; ++ i)
  605.     {
  606.         long long w = M / m[i];
  607.         extend_gcd(m[i],w,d,d,y);
  608.         x = (x + y*w*a[i])%M;
  609.     }
  610.     return (x+M)%M;
  611. }
  613. 高斯消元（高精度）
  614. const int MatrixSize = 50;
  615. const double eps = 1e-8;
  616. typedef double Matrix[MatrixSize][MatrixSize];
  618. void Gauss(Matrix A, int n)
  619. {
  620.   int i, j, k, r;
  621.   for(i = 0; i < n; ++ i)
  622.   {
  623.       r = i;
  624.       for(j = i+1; j < n; ++ j)
  625.         if (fabs(A[j][i]) > fabs(A[r][i])) r = j;
  626.       if(fabs(A[r][i]) < eps) continue;
  627.       if(r != i) for(j = 0; j <= n; j++) swap(A[r][j], A[i][j]);
  628.       for(k = 0; k < n; k++) if(k != i)
  629.         for(j = n; j >= i; j--) A[k][j] -= A[k][i]/A[i][i] * A[i][j];
  630.   }
  631.   for(i = 0 ; i < n ; ++ i)
  632.   {
  633.          if(fabs(A[i][n]) < eps) A[i][n] = 0;
  634.          else A[i][n] /= A[i][i];
  635.   }
  636. }
  638. 算原根
  639. #include <iostream>
  640. #include <cstdlib>
  641. #include <cstring>
  642. #include <cstdio>
  643. using namespace std;
  644. int P;
  645. const int NUM = 32170;
  646. int prime[NUM/4];
  647. bool f[NUM];
  648. int pNum = 0;
  649. void getPrime()//线性筛选素数
  650. {
  651.     for (int i = 2; i < NUM; ++ i)
  652.     {
  653.         if (!f[i])
  654.         {
  655.             f[i] = 1;
  656.             prime[pNum++] = i;
  657.         }
  658.         for (int j = 0; j < pNum && i*prime[j] < NUM; ++ j)
  659.         {
  660.             f[i*prime[j]] = 1;
  661.             if (i%prime[j] == 0)
  662.             {
  663.                 break;
  664.             }
  665.         }
  666.     }
  667. }
  668. __int64 getProduct(int a,int b,int P)//快速求次幂mod
  669. {
  670.     __int64 ans = 1;
  671.     __int64 tmp = a;
  672.     while (b)
  673.     {
  674.         if (b&1)
  675.         {
  676.             ans = ans*tmp%P;
  677.         }
  678.         tmp = tmp*tmp%P;
  679.         b>>=1;
  680.     }
  681.     return ans;
  682. }
  684. bool judge(int num)//求num的所有的质因子
  685. {
  686.     int elem[1000];
  687.     int elemNum = 0;
  688.     int k = P - 1;
  689.     for (int i = 0; i < pNum; ++ i)
  690.     {
  691.         bool flag = false;
  692.         while (!(k%prime[i]))
  693.         {
  694.             flag = true;
  695.             k /= prime[i];
  696.         }
  697.         if (flag)
  698.         {
  699.             elem[elemNum ++] = prime[i];
  700.         }
  701.         if (k==1)
  702.         {
  703.             break;
  704.         }
  705.         if (k/prime[i]<prime[i])
  706.         {
  707.             elem[elemNum ++] = prime[i];
  708.             break;
  709.         }
  710.     }
  711.     bool flag = true;
  712.     for (int i = 0; i < elemNum; ++ i)
  713.     {
  714.         if (getProduct(num,(P-1)/elem[i],P) == 1)
  715.         {
  716.             flag = false;
  717.             break;
  718.         }
  719.     }
  720.     return flag;
  721. }
  722. int main()
  723. {
  725.     getPrime();
  726.     while (cin >> P)
  727.     {
  728.         for (int i = 2; i <= P ;++i)
  729.         {
  730.             if (judge(i))
  731.             {
  732.                 cout << i<< endl;
  733.                 break;
  734.             }
  735.         }
  736.     }
  737.     return 0;
  738. }
  740. 降幂公式
  741. A^x = A^(x % Phi(C) + Phi(C)) (mod C)，其中x≥Phi(C)  这个降幂公式适用于C不是素数的情况
  742. A ^ X % C = A ^ ( X % ( C - 1 ) )  这个降幂公式只适用于C是素数的情况
  744. 回文自动机
  745. struct Palindromic_Auto{
  746.     const static int maxn = 2e5 + 15;
  747.     const static int lettersz = 26;
  748.     int link[maxn] , len[maxn] , last , tot , nxt[maxn][lettersz] , s[maxn] , n ;
  749.     void init( int id , int l ){ memset( nxt[id] , 0 , sizeof( nxt[id] ) ); len[id] = l; }
  750.     void init(){ n = last = 0 , s[0] = -1 , link[0] = tot = 1; init( 0 , 0  ) , init( 1 , -1 ); }
  751.     int gethash( char c ){ return c -'a' ;}
  752.     int extend( char c ){
  753.         s[ ++ n ] = gethash( c );
  754.         int cur = last ;
  755.         while( s[n - len[cur] - 1] != s[n] ) cur = link[cur];
  756.         if( !nxt[cur][s[n]] ){
  757.             int id = ++ tot , t = link[cur] ; init( id , len[cur] + 2 );
  758.             while( s[n - len[t] - 1] != s[n] ) t = link[t];
  759.             link[id] = nxt[t][s[n]] , nxt[cur][s[n]] = id;
  760.         }
  761.         last = nxt[cur][s[n]];
  762.         return len[last];
  763.     }
  764. }pa_auto;
  766. 后缀自动机
  767. struct Suffix_Auto{
  768.     const static int maxn = ( 1e5 + 50 ) * 2;
  769.     const static int lettersz = 26;
  770.     int tot , last , link[maxn] , nxt[maxn][lettersz] , len[maxn];
  771.     int gethash( char c ){ return c -'a' ;}
  772.     void init( int idx ){ link[idx] = len[idx] = 0 , memset( nxt[idx] , 0 , sizeof( nxt[idx] ) ); }
  773.     void init(){ memset(nxt[0],0,sizeof(nxt[0])) ; last = tot = len[0] = 0 , link[0] = -1 ; }
  774.     void extend( char c ){
  775.         int cur = ++ tot , p , q , id = gethash( c ) ;
  776.         init( cur ) ;
  777.         len[cur] = len[last] + 1;
  778.         for( p = last ; ~p && !nxt[p][id] ; p = link[p] ) nxt[p][id] = cur;
  779.         if( ~p ){
  780.             q = nxt[p][id];
  781.             if( len[p] + 1 == len[q] ) link[cur] = q;
  782.             else{
  783.                 // Pay attention to init for clone , such as cnt array
  784.                 int clone = ++ tot ;
  785.                 len[clone] = len[p] + 1 , memcpy( nxt[clone] , nxt[q] , sizeof(int)*lettersz ) , link[clone] = link[q];
  786.                 for( ; ~p && nxt[p][id] == q ; p = link[p] ) nxt[p][id] = clone;
  787.                 link[q] = link[cur] = clone;
  788.             }
  789.         }
  790.         last = cur;
  791.     }
  792. }Sam;
  794. 后缀数组
  795. struct SuffixArray{
  796.     const static int maxn = 1e5 + 50;
  797.     int sa[maxn],c[maxn],sq[maxn],sw[maxn],rank[maxn],height[maxn];
  798.     void Build(int *s,int n,int m){
  799.         ++ n;
  800.         int * x = sq , *y = sw , p = 1 ;
  801.         for(int i = 0 ; i < m ; ++ i) c[i] = 0;
  802.         for(int i = 0 ; i < n ; ++ i) c[x[i]=s[i]]++;
  803.         for(int i = 1 ; i < m ; ++ i) c[i] += c[i - 1];
  804.         for(int i = n - 1 ; i >= 0 ; -- i) sa[--c[x[i]]] = i;
  805.         for(int k = 1 ; p < n ; k <<= 1){
  806.             p = 0;
  807.             for(int i = n - k ; i < n ; ++ i) y[p ++] = i;
  808.             for(int i = 0 ; i < n ; ++ i) if( sa[i] >= k ) y[p ++] = sa[i] - k;
  809.             for(int i = 0 ; i < m ; ++ i) c[i] = 0;
  810.             for(int i = 0 ; i < n ; ++ i) c[x[y[i]]]++;
  811.             for(int i = 1 ; i < m ; ++ i) c[i] += c[i-1];
  812.             for(int i = n - 1 ; i >= 0 ; -- i) sa[--c[x[y[i]]]]=y[i];
  813.             swap( x , y ) ; p = 1 , x[sa[0]] = 0;
  814.             for(int i = 1 ; i < n ; ++ i) x[sa[i]] = y[sa[i - 1]] == y[sa[i]] && y[sa[i - 1] + k] == y[sa[i] + k] ? p - 1 : p++;
  815.             m = p;
  816.         }
  817.         -- n;
  818.         for(int i = 0 ; i < n ; ++ i) sa[i] = sa[i + 1] , rank[sa[i]] = i;
  819.         for(int i = 0 , k = 0 ; i < n ; ++ i ){
  820.             if( !rank[i] ) continue;
  821.             int j = sa[rank[i] - 1];
  822.             if( k ) -- k;
  823.             while( s[i + k] == s[j + k] ) ++ k;
  824.             height[rank[i]] = k;
  825.         }
  826.     }
  827. }Sa;
  829. 马拉车
  830. void manacher(char s[],int l)
  831. {
  832.    int i,j,k,ans=0;
  833.    for(i=1;i<=l;++i)str[i<<1]=s[i],str[(i<<1)+1]='#';
  834.    str[1]='#';str[l*2+1]='#';str[0]='&';str[l*2+2]='$';
  835.    l=l*2+1;j=0;
  836.    for(i=1;i<=l;)
  837.    {
  838.        while(str[i-j-1]==str[i+j+1])++j;
  839.        p[i]=j;if(j>ans)ans=j;
  840.        for(k=1;k<=j&&p[i]-k!=p[i-k];++k)p[i+k]=min(p[i-k],p[i]-k);
  841.        i+=k;j=max(j-k,0);
  842.    }
  843. }
  845. LCT 动态树
  846. Push是往下传，update是往上传
  847. const int MAXN = 200500;struct Node {
  848.     Node *ch[2], *p; int size, value;
  849.     bool rev;
  850.     Node(int t = 0);
  851.     inline bool dir(void) {return p->ch[1] == this;}
  852.     inline void SetC(Node *x, bool d) {
  853.         ch[d] = x; x->p = this;
  854.     }
  855.     inline void Rev(void) {
  856.         swap(ch[0], ch[1]); rev ^= 1;
  857.     }
  858.     inline void Push(void) {
  859.         if (rev) {
  860.             ch[0]->Rev();
  861.             ch[1]->Rev();
  862.             rev = 0;
  863.         }
  864.     }
  865.     inline void Update(void) {
  866.         size = ch[0]->size + ch[1]->size + 1;
  867.     }
  868. }Tnull, *null = &Tnull, *fim[MAXN];// 要记得额外更新null的信息
  869. Node::Node(int _value){ch[0] = ch[1] = p = null; rev = 0;}
  870. inline bool isRoot(Node *x) {return x->p == null || (x != x->p->ch[0] && x != x->p->ch[1]);}
  871. inline void rotate(Node *x) {
  872.     Node *p = x->p; bool d = x->dir();
  873.     p->Push(); x->Push();
  874.     if (!isRoot(p)) p->p->SetC(x, p->dir()); else x->p = p->p;
  875.     p->SetC(x->ch[!d], d);
  876.     x->SetC(p, !d);
  877.     p->Update();
  878. }
  879. inline void splay(Node *x) {
  880.     x->Push();
  881.     while (!isRoot(x)) {
  882.         if (isRoot(x->p)) rotate(x);
  883.         else {
  884.             if (x->dir() == x->p->dir()) {rotate(x->p); rotate(x);}
  885.             else {rotate(x); rotate(x);}
  886.         }
  887.     }
  888.     x->Update();
  889. }
  890. inline Node* Access(Node *x) {
  891.     Node *t = x, *q = null;
  892.     for (; x != null; x = x->p) {
  893.         splay(x); x->ch[1] = q; q = x;
  894.     }
  895.     splay(t); //info will be updated in the splay;
  896.     return q;
  897. }
  898. inline void Evert(Node *x) {
  899.     Access(x); x->Rev();
  900. }
  901. inline void link(Node *x, Node *y) {
  902.     Evert(x); x->p = y;
  903. }
  904. inline Node* getRoot(Node *x) {
  905.     Node *tmp = x;
  906.     Access(x);
  907.     while (tmp->Push(), tmp->ch[0] != null) tmp = tmp->ch[0];
  908.     splay(tmp);
  909.     return tmp;
  910. }// 一定要确定x和y之间有边
  911. inline void cut(Node *x, Node *y) {
  912.     Access(x); splay(y);
  913.     if (y->p != x) swap(x, y);
  914.     Access(x); splay(y);
  915.     y->p = null;
  916. }
  917. inline Node* getPath(Node *x, Node *y) {
  918.     Evert(x); Access(y);
  919.     return y;
  920. }
  921. inline void clear(void) {
  922.     null->rev = 0; null->size = 0; null->value = 0;
  923. }int a[maxn];int main()
  924. {
  925.     clear();
  926.     int n=read();
  927.     for(int i=0;i<=n+1;i++)
  928.         fim[i] = new Node();
  929.     for(int i=1;i<=n;i++)
  930.         a[i]=read();
  931.     for(int i=1;i<=n;i++)
  932.     {
  933.         int p = i+a[i];
  934.         if(p>n)p=n+1;
  935.         link(fim[i],fim[p]);
  936.     }
  937.     int m = read();
  938.     while(m--)
  939.     {
  940.         int op = read();
  941.         if(op == 1)
  942.         {
  943.             int x = read();
  944.             x++;
  945.             Access(fim[x]);
  946.             splay(fim[x]);
  947.             printf("%d\n",fim[x]->size - 1);
  948.         }
  949.         else
  950.         {
  951.             int x=read(),y=read();
  952.             x++;
  953.             int p = x+a[x];
  954.             if(p>n)p=n+1;
  955.             cut(fim[x],fim[p]);
  956.             a[x]=y;
  957.             p = x+a[x];
  958.             if(p>n)p=n+1;
  959.             link(fim[x],fim[p]);
  960.         }
  961.     }
  962. }
  963. Splay
  964. struct SplayTree{
  966.     const static int maxn = 2e5 + 15;
  968.     int ch[maxn][2] , s[maxn] , tot , root , fa[maxn];
  969.     long long sum[maxn] , lzy[maxn] ;
  970.     int index[maxn] , key[maxn];
  972.     void init( int x , int id = 0 , int val = 0 , int par = 0 ){
  973.         ch[x][0]=ch[x][1]=0 , fa[x]= par , key[x] = val , index[x] = id , s[x] = 1;
  974.     }
  976.     void init(){
  977.         init( 0 , 0 , 0 , 0 ); s[0] = 0;
  978.         tot = root = 0 ;
  979.     }
  981.     inline void up(int x){
  982.         s[x] = s[ch[x][0]] + s[ch[x][1]] + 1;
  983.         sum[x] = key[x];
  984.         if( ch[x][0] ) sum[x] += sum[ch[x][0]];
  985.         if( ch[x][1] ) sum[x] += sum[ch[x][1]];
  986.     }
  988.     void update( int x , long long v ){
  989.         lzy[x] += v;
  990.         sum[x] += s[x] * v;
  991.         key[x] += v;
  992.     }
  994.     void ReleaseLabel( int x ){
  995.         if( lzy[x] ){
  996.             if( ch[x][0] ) update( ch[x][0] , lzy[x] );
  997.             if( ch[x][1] ) update( ch[x][1] , lzy[x] );
  998.             lzy[x] = 0;
  999.         }
  1000.     }
  1002.     void rotate( int x, int d ){
  1003.         int y = fa[x];
  1004.         //cout << "y is " << y << " lzy is " << lzy[y] << endl;
  1005.         ReleaseLabel( y );
  1006.         ReleaseLabel( x );
  1007.         ch[y][d ^ 1] = ch[x][d];
  1008.         if ( ch[x][d]) fa[ch[x][d]] = y;
  1009.         fa[x] = fa[y];
  1010.         if (fa[y]){
  1011.             if (y == ch[fa[y]][d])  ch[fa[y]][d] = x;
  1012.             else  ch[fa[y]][d ^ 1] = x;
  1013.         }
  1014.         ch[x][d] = y , fa[y] = x;
  1015.         up( y );
  1016.         up( x );
  1017.     }
  1019.     // Splay x to target's son
  1020.     void Splay( int x , int target ){
  1021.         ReleaseLabel( x ); // Very Improtant !!!!
  1022.         while( fa[x] != target ){
  1023.             int y = fa[x];
  1024.             if( x == ch[y][0] ){
  1025.                 if( fa[y] != target && y == ch[fa[y]][0])
  1026.                     rotate( y , 1 );
  1027.                 rotate( x , 1 );
  1028.             }else{
  1029.                 if( fa[y] != target && y == ch[fa[y]][1])
  1030.                     rotate( y , 0 );
  1031.                 rotate( x , 0 );
  1032.             }
  1033.         }
  1034.         if( !target ) root = x;
  1035.     }
  1037.     int insert( int & x , int id , int val , int par = 0 ){
  1038.         int rs;
  1039.         if( x == 0 ){
  1040.             x = ++ tot;
  1041.             rs = x;
  1042.             init( tot , id , val , par );
  1043.         }else{
  1044.             int cur = x;
  1045.             ReleaseLabel( cur );
  1046.             if( id < index[x] ) rs = insert( ch[x][0] , id , val , x );
  1047.             else rs = insert( ch[x][1] , id , val , x );
  1048.         }
  1049.         up( x );
  1050.         return rs;
  1051.     }
  1053.     int pred( int t , int v ){
  1054.         if( t == 0 ) return -1;
  1055.         if( v <= index[t] ) return pred( ch[t][0] , v );
  1056.         else{
  1057.             int rs = pred( ch[t][1] , v );
  1058.             if( rs == -1 ) return t;
  1059.             return rs;
  1060.         }
  1061.     }
  1063.     int succ( int t , int v ){
  1064.         if( t == 0 ) return -1;
  1065.         if( v >= index[t] ) return succ( ch[t][1] , v );
  1066.         else{
  1067.             int rs = succ( ch[t][0] , v );
  1068.             if( rs == -1 ) return t;
  1069.             return rs;
  1070.         }
  1071.     }
  1073.     // After GotSegement( l , r ) must use Splay funtion to Modify son's information to the root
  1074.     int GetSegement( int l , int r ){
  1075.         int s1 = pred( root , l ) , s2 = succ( root , r );
  1076.         if( s1 == -1 && s2 == -1 ) return root;
  1077.         else if( s1 == -1 ){
  1078.             Splay( s2 , 0 );
  1079.             return ch[s2][0];
  1080.         }else if( s2 == -1 ){
  1081.             Splay( s1 , 0 );
  1082.             return ch[s1][1];
  1083.         }else{
  1084.             Splay( s1 , 0 );
  1085.             Splay( s2 , s1 );
  1086.             return ch[s2][0];
  1087.         }
  1088.     }
  1090.     void Delete( int l , int r ){
  1091.         int s1 = pred( root , l ) , s2 = succ( root , r );
  1092.         if( s1 == -1 && s2 == -1 ){
  1093.             fa[ch[root][0]] = 0;
  1094.             fa[ch[root][1]] = 0;
  1095.             root = 0;
  1096.         }
  1097.         else if( s1 == -1 ){
  1098.             Splay( s2 , 0 );
  1099.             fa[ch[s2][0]] = 0;
  1100.             ch[s2][0] = 0;
  1101.             up( s2 );
  1102.         }else if( s2 == -1 ){
  1103.             Splay( s1 , 0 );
  1104.             fa[ch[s1][1]] = 0;
  1105.             ch[s1][1] = 0 ;
  1106.             up( s1 );
  1107.         }else{
  1108.             Splay( s1 , 0 );
  1109.             Splay( s2 , s1 );
  1110.             fa[ch[s2][0]] = 0;
  1111.             ch[s2][0] = 0;
  1112.             up( s2 );
  1113.             up( s1 );
  1114.         }
  1115.     }
  1117. }splay;
  1118. FWT
  1119. #include <bits/stdc++.h>
  1121. using namespace std;
  1123. const int N = 1 << 20;
  1125. int a[N];
  1127. void tfand(int a[], int n) {
  1128.     if(n == 1) return;
  1129.     int x = n >> 1;
  1130.     tfand(a, x); tfand(a + x, x);
  1131.     for(int i = 0; i < x; ++ i)
  1132.         a[i] += a[i + x];
  1133. }
  1135. void utfand(long long a[], int n) {
  1136.     if(n == 1) return;
  1137.     int x = n >> 1;
  1138.     for(int i = 0; i < x; ++ i)
  1139.         a[i] -= a[i + x];
  1140.     utfand(a, x); utfand(a + x, x);
  1141. }
  1143. void tfor(int a[], int n) {
  1144.     if(n == 1) return;
  1145.     int x = n >> 1;
  1146.     tfor(a, x); tfor(a + x, x);
  1147.     for(int i = 0; i < x; ++ i)
  1148.         a[i + x] += a[i];
  1149. }
  1151. void utfor(long long a[], int n) {
  1152.     if(n == 1) return;
  1153.     int x = n >> 1;
  1154.     for(int i = 0; i < x; ++ i)
  1155.         a[i + x] -= a[i];
  1156.     utfor(a, x); utfor(a + x, x);
  1157. }
  1159. long long t[N];
  1161. void utfxor(long long a[], int n) {
  1162.     if(n == 1) return;
  1163.     int x = n >> 1;
  1164.     for(int i = 0; i < x; ++ i) {
  1165.         t[i] = (a[i] + a[i + x]) >> 1;
  1166.         t[i + x] = (a[i + x] - a[i]) >> 1;
  1167.     }
  1168.     memcpy(a, t, n * sizeof(long long));
  1169.     utfxor(a, x); utfxor(a + x, x);
  1170. }
  1172. int tmp[N];
  1174. void tfxor(int a[], int n) {
  1175.     if(n == 1) return;
  1176.     int x = n >> 1;
  1177.     tfxor(a, x); tfxor(a + x, x);
  1178.     for(int i = 0; i < x; ++ i) {
  1179.         tmp[i] = a[i] - a[i + x];
  1180.         tmp[i + x] = a[i] + a[i + x];
  1181.     }
  1182.     memcpy(a, tmp, n * sizeof(int));
  1183. }
  1185. long long b[N];
  1187. int c[N];
  1189. int main() {
  1190.     int T, cas = 1;
  1191.     scanf("%d", &T);
  1192.     while(T --) {
  1193.         int n, op;
  1194.         scanf("%d%d", &n, &op);
  1195.         memset(a, 0, sizeof(a));
  1196.         for(int i = 0; i < n; ++ i) {
  1197.             scanf("%d", c + i);
  1198.             ++ a[c[i]];
  1199.         }
  1200.         if(op == 1) {
  1201.             tfand(a, 1 << 20);
  1202.         } else if(op == 2) {
  1203.             tfxor(a, 1 << 20);
  1204.         } else {
  1205.             tfor(a, 1 << 20);
  1206.         }
  1207.         for(int i = 0; i < 1 << 20; ++ i)
  1208.             b[i] = (long long)a[i] * a[i];
  1209.         if(op == 1) {
  1210.             utfand(b, 1 << 20);
  1211.         } else if(op == 2) {
  1212.             utfxor(b, 1 << 20);
  1213.         } else {
  1214.             utfor(b, 1 << 20);
  1215.         }
  1216.         if(op != 2) {
  1217.             for(int i = 0; i < n; ++ i) -- b[c[i]];
  1218.         }
  1219.         int ans = 0;
  1220.         for(int i = (1 << 20) - 1; i >= 0; -- i) if(b[i]) {
  1221.             ans = i;
  1222.             break;
  1223.         }
  1224.         printf("Case #%d: %d\n", cas ++, ans);
  1225.     }
  1226.     return 0;
  1227. }
  1228. 博弈论
  1230.     Nim Game
  1231.         最经典最基础的博弈.
  1232.         n堆石子,双方轮流从任意一堆石子中取出至少一个,不能取的人输.
  1233.         对于一堆x个石子的情况,容易用归纳法得到SG(x)=x.
  1234.         所以所有石子个数的异或和为0是必败态,否则为必胜态.
  1236.     Bash Game
  1237.         每人最多一次只能取m个石子,其他规则同Nim Game.
  1238.         依旧数学归纳…SG(x)=xmod(m+1).
  1240.     NimK Game
  1241.         每人一次可以从最多K堆石子中取出任意多个,其他规则同Nim Game.
  1242.         结论:在二进制下各位上各堆石子的数字之和均为(K+1)的倍数的话则为必败态,否则为必胜态.
  1243.         这个证明要回到原始的方法上去.
  1244.         补:这个游戏还可以推广,即一个由n个子游戏组成的游戏,每次可以在最多K个子游戏中进行操作.
  1245.         然后只要把结论中各堆石子的个数改为各个子游戏的SG值即可,证明也还是一样的.
  1247.     Anti-Nim Game
  1248.         似乎又叫做Misère Nim.
  1249.         不能取的一方获胜,其他规则同Nim Game.
  1250.         关于所谓的”Anti-SG游戏”及”SJ定理”贾志鹏的论文上有详细说明,不过似乎遇到并不多.
  1251.         结论是一个状态是必胜态当且仅当满足以下条件之一:
  1252.         SG值不为0且至少有一堆石子数大于1;
  1253.         SG值为0且不存在石子数大于1的石子堆.
  1255.     Staircase Nim
  1256.         每人一次可以从第一堆石子中取走若干个,或者从其他石子堆的一堆中取出若干个放到左边一堆里(没有石子的石子堆不会消失),其他规则同Nim Game.
  1257.         这个游戏的结论比较神奇:
  1258.         当且仅当奇数编号堆的石子数异或和为0时为必败态.
  1259.         简单的理解是从偶数编号堆中取石子对手又可以放回到奇数编号堆中,而且不会让对手不能移动.比较意识流,然而可以归纳证明.
  1261.     Wythoff Game
  1262.         有两堆石子,双方轮流从某一堆取走若干石子或者从两堆中取走相同数目的石子,不能取的人输.
  1263.         容易推理得出对任意自然数k,都存在唯一的一个必败态使得两堆石子数差为k,设其为Pk=(ak,bk),表示石子数分别为ak,bk(ak⩽bk).
  1264.         那么ak为在Pk0(k0<k)中未出现过的最小自然数,bk=ak+k.
  1265.         数学班的说,用Betty定理以及显然的单调性就可以推出神奇的结论:
  1266.         ak=⌊k⋅5√+12⌋,bk=⌊k⋅5√+32⌋.
  1268.     Take & Break
  1269.         有n堆石子,双方轮流取出一堆石子,然后新增两堆规模更小的石子堆(可以没有石子),无法操作者输.
  1270.         这个游戏似乎只能暴力SG,知道一下就好.
  1272.     树上删边游戏
  1273.         给出一个有n个结点的树，有一个点作为树的根节点,双方轮流从树中删去一条边边，之后不与根节点相连的部分将被移走,无法操作者输.
  1274.         结论是叶子结点的SG值为0,其他结点SG值为其每个儿子结点SG值加1后的异或和,证明也并不复杂.
  1276. 下面两个游戏我不太会,于是偷懒引用贾志豪《组合游戏略述——浅谈 SG 游戏的若干拓展及变形》中的内容了.
  1278.     翻硬币游戏
  1280.         n枚硬币排成一排，有的正面朝上，有的反面朝上。
  1281.         游戏者根据某些约束翻硬币（如：每次只能翻一或两枚，或者每次只能翻连续的几枚），但他所翻动的硬币中，最右边的必须是从正面翻到反面。
  1282.         谁不能翻谁输。
  1284.         需要先开动脑筋把游戏转化为其他的取石子游戏之类的,然后用如下定理解决:
  1285.         局面的 SG 值等于局面中每个正面朝上的棋子单一存在时的 SG 值的异或和。
  1287.     无向图删边游戏
  1289.         一个无向连通图，有一个点作为图的根。
  1290.         游戏者轮流从图中删去边， 删去一条边后，不与根节点相连的部分将被移走。
  1291.         谁无路可走谁输。
  1293.         对于这个模型，有一个著名的定理——Fusion Principle:
  1294.         我们可以对无向图做如下改动：将图中的任意一个偶环缩成一个新点，任意一个奇环缩成一个新点加一个新边；所有连到原先环上的边全部改为与新点相连。 这样的改动不会影响图的 SG 值。
  1296. 数学
  1297. 奇怪的数学公式系列：
  1299. 欧拉函数：
  1301. 在数论，对正整数n，欧拉函数是小于n的数中与n互质的数的数目。此函数以其首名研究者欧拉命名，它又称为Euler's totient function、φ函数、欧拉商数等。 例如φ(8)=4，因为1,3,5,7均和8互质。 从欧拉函数引伸出来在环论方面的事实和拉格朗日定理构成了欧拉定理的证明。
  1303. φ函数的值：通式：φ(x)=x(1-1/p1)(1-1/p2)(1-1/p3)(1-1/p4)…..(1-1/pn),其中p1, p2……pn为x的所有质因数，x是不为0的整数。φ(1)=1（唯一和1互质的数(小于等于1)就是1本身）。 (注意：每种质因数只一个。比如12=2*2*3那么φ（12）=12*（1-1/2）*(1-1/3)=4
  1304. 若n是质数p的k次幂，φ(n)=p^k-p^(k-1)=(p-1)p^(k-1)，因为除了p的倍数外，其他数都跟n互质。
  1306. 设n为正整数，以 φ(n)表示不超过n且与n互素的正整数的个数，称为n的欧拉函数值，这里函数
  1307. φ：N→N，n→φ(n)称为欧拉函数。
  1309. 欧拉函数是积性函数——若m,n互质，φ(mn)=φ(m)φ(n)。
  1311. 特殊性质：当n为奇数时，φ(2n)=φ(n), 证明与上述类似。
  1313. 若n为质数则φ(n)=n-1。
  1315. long long phi[maxn];
  1316. void phi1()
  1317. {
  1318.     memset(phi,0,sizeof(phi));
  1319.     phi[1]=1;
  1320.     for(long long i=2;i<=n;i++)
  1321.     {
  1322.         if(!phi[i])
  1323.         {
  1324.             for(long long j=i;j<=n;j+=i)
  1325.             {
  1326.                 if(!phi[j]) phi[j]=j;
  1327.                 phi[j]=phi[j]/i*(i-1);
  1328.             }
  1329.         }
  1330.     }
  1331. }
  1333. 另外一种：
  1335. long long phi(long long n)
  1336. {
  1337.     long long tmp=n;
  1338.     for(long long i=2;i*i<=n;i++)
  1339.         if(n%i==0)
  1340.         {
  1341.             tmp/=i;tmp*=i-1;
  1342.             while(n%i==0)n/=i;
  1343.         }
  1344.     if(n!=1)tmp/=n,tmp*=n-1;
  1345.     return tmp;
  1346. }
  1348. 排列组合
  1350. #include<bits/stdc++.h>
  1351. using namespace std;
  1352. const int maxn = 1e6+7;
  1353. const int mod = 1e9+7;
  1354. long long fac[maxn];
  1355. long long qpow(long long a,long long b)
  1356. {
  1357.     long long ans=1;a%=mod;
  1358.     for(long long i=b;i;i>>=1,a=a*a%mod)
  1359.         if(i&1)ans=ans*a%mod;
  1360.     return ans;
  1361. }
  1362. long long C(long long n,long long m)
  1363. {
  1364.     if(m>n||m<0)return 0;
  1365.     long long s1=fac[n],s2=fac[n-m]*fac[m]%mod;
  1366.     return s1*qpow(s2,mod-2)%mod;
  1367. }
  1368. int main()
  1369. {
  1370.     fac[0]=1;
  1371.     for(int i=1;i<maxn;i++)
  1372.         fac[i]=fac[i-1]*i%mod;
  1373. }
  1375. 逆元
  1377. int gcd(int a, int b, int& x, int& y) {
  1378.     if (!a) {
  1379.         x = 0, y = 1;
  1380.         return b;
  1381.     }
  1382.     int xx, yy, g = gcd(b % a, a, xx, yy);
  1383.     x = yy - b / a * xx;
  1384.     y = xx;
  1385.     return g;
  1386. }
  1388. inline int normal(int n) {
  1389.     n %= mod;
  1390.     (n < 0) && (n += mod);
  1391.     return n;
  1392. }
  1394. inline int inv(int a) {
  1395.     int x, y;
  1396.     assert(gcd(a, mod, x, y) == 1);
  1397.     return normal(x);
  1398. }
  1400. inline int add(int a, int b) { return a + b >= mod ? a + b - mod : a + b; }
  1401. inline int sub(int a, int b) { return a - b < 0 ? a - b + mod : a - b; }
  1402. inline int mul(int a, int b) { return int(a * 1ll * b % mod); }
  1403. inline int _div(int a, int b) { return mul(a, inv(b)); }
  1405. 统计二进制有多少个1
  1406. cnt[i]＝cnt[i>>1]+(i&1);
  1408. popcount(int x){
  1409.     return cnt[x>>16]+cnt[x&((1<<16)-1)];
  1410. }
  1412. 网络流
  1413. namespace NetFlow
  1414. {
  1415.     const int MAXN=100000,MAXM=100000,inf=1e9;
  1416.     struct Edge
  1417.     {
  1418.         int v,c,f,nx;
  1419.         Edge() {}
  1420.         Edge(int v,int c,int f,int nx):v(v),c(c),f(f),nx(nx) {}
  1421.     } E[MAXM];
  1422.     int G[MAXN],cur[MAXN],pre[MAXN],dis[MAXN],gap[MAXN],N,sz;
  1423.     void init(int _n)
  1424.     {
  1425.         N=_n,sz=0; memset(G,-1,sizeof(G[0])*N);
  1426.     }
  1427.     void link(int u,int v,int c)
  1428.     {
  1429.         E[sz]=Edge(v,c,0,G[u]); G[u]=sz++;
  1430.         E[sz]=Edge(u,0,0,G[v]); G[v]=sz++;
  1431.     }
  1432.     int ISAP(int S,int T)
  1433.     {//S -> T
  1434.         int maxflow=0,aug=inf,flag=false,u,v;
  1435.         for (int i=0;i<N;++i)cur[i]=G[i],gap[i]=dis[i]=0;
  1436.         for (gap[S]=N,u=pre[S]=S;dis[S]<N;flag=false)
  1437.         {
  1438.             for (int &it=cur[u];~it;it=E[it].nx)
  1439.             {
  1440.                 if (E[it].c>E[it].f&&dis[u]==dis[v=E[it].v]+1)
  1441.                 {
  1442.                     if (aug>E[it].c-E[it].f) aug=E[it].c-E[it].f;
  1443.                     pre[v]=u,u=v; flag=true;
  1444.                     if (u==T)
  1445.                     {
  1446.                         for (maxflow+=aug;u!=S;)
  1447.                         {
  1448.                             E[cur[u=pre[u]]].f+=aug;
  1449.                             E[cur[u]^1].f-=aug;
  1450.                         }
  1451.                         aug=inf;
  1452.                     }
  1453.                     break;
  1454.                 }
  1455.             }
  1456.             if (flag) continue;
  1457.             int mx=N;
  1458.             for (int it=G[u];~it;it=E[it].nx)
  1459.             {
  1460.                 if (E[it].c>E[it].f&&dis[E[it].v]<mx)
  1461.                 {
  1462.                     mx=dis[E[it].v]; cur[u]=it;
  1463.                 }
  1464.             }
  1465.             if ((--gap[dis[u]])==0) break;
  1466.             ++gap[dis[u]=mx+1]; u=pre[u];
  1467.         }
  1468.         return maxflow;
  1469.     }
  1470.     bool bfs(int S,int T)
  1471.     {
  1472.         static int Q[MAXN]; memset(dis,-1,sizeof(dis[0])*N);
  1473.         dis[S]=0; Q[0]=S;
  1474.         for (int h=0,t=1,u,v,it;h<t;++h)
  1475.         {
  1476.             for (u=Q[h],it=G[u];~it;it=E[it].nx)
  1477.             {
  1478.                 if (dis[v=E[it].v]==-1&&E[it].c>E[it].f)
  1479.                 {
  1480.                     dis[v]=dis[u]+1; Q[t++]=v;
  1481.                 }
  1482.             }
  1483.         }
  1484.         return dis[T]!=-1;
  1485.     }
  1486.     int dfs(int u,int T,int low)
  1487.     {
  1488.         if (u==T) return low;
  1489.         int ret=0,tmp,v;
  1490.         for (int &it=cur[u];~it&&ret<low;it=E[it].nx)
  1491.         {
  1492.             if (dis[v=E[it].v]==dis[u]+1&&E[it].c>E[it].f)
  1493.             {
  1494.                 if (tmp=dfs(v,T,min(low-ret,E[it].c-E[it].f)))
  1495.                 {
  1496.                     ret+=tmp; E[it].f+=tmp; E[it^1].f-=tmp;
  1497.                 }
  1498.             }
  1499.         }
  1500.         if (!ret) dis[u]=-1; return ret;
  1501.     }
  1502.     int dinic(int S,int T)
  1503.     {
  1504.         int maxflow=0,tmp;
  1505.         while (bfs(S,T))
  1506.         {
  1507.             memcpy(cur,G,sizeof(G[0])*N);
  1508.             while (tmp=dfs(S,T,inf)) maxflow+=tmp;
  1509.         }
  1510.         return maxflow;
  1511.     }
  1512. }
  1513. 费用流
  1514. struct ZKW_MinCostMaxFlow{
  1516.     const static int maxn = 1e5 + 50;
  1517.     const static int maxE = 1e5 + 50;
  1518.     const static int INF = 0x3f3f3f3f;
  1520.     struct Edge{
  1521.         int to,next,cap,flow,cost;
  1522.         Edge(int _to=0,int _next=0,int _cap=0,int _flow=0,int _cost=0):
  1523.             to(_to),next(_next),cap(_cap),flow(_flow),cost(_cost){}
  1524.     }edge[maxE * 2];
  1526.     int head[maxn],tot;
  1527.     int cur[maxn];
  1528.     int dis[maxn];
  1529.     bool vis[maxn];
  1530.     int ss,tt,N;
  1531.     int min_cost,max_flow;
  1532.     void init(int N){
  1533.         tot=0;
  1534.         for( int i = 0 ; i < N ; ++ i ) head[i] = -1;
  1535.     }
  1536.     int addedge(int u,int v,int cap,int cost){
  1537.         edge[tot]=Edge(v,head[u],cap,0,cost);
  1538.         int rs = tot;
  1539.         head[u]=tot++;
  1540.         edge[tot]=Edge(u,head[v],0,0,-cost);
  1541.         head[v]=tot++;
  1542.         return rs;
  1543.     }
  1544.     int aug(int u,int flow){
  1545.         if(u==tt) return flow;
  1546.         vis[u]=true;
  1547.         for(int i=cur[u];i!=-1;i=edge[i].next){
  1548.             int v=edge[i].to;
  1549.             if( edge[i].cap>edge[i].flow && !vis[v] && dis[u]==dis[v]+edge[i].cost ){
  1550.                 int tmp=aug(v,min(flow,edge[i].cap-edge[i].flow));
  1551.                 edge[i].flow+=tmp;
  1552.                 edge[i^1].flow-=tmp;
  1553.                 cur[u]=i;
  1554.                 if(tmp) return tmp;
  1555.             }
  1556.         }
  1557.         return 0;
  1558.     }
  1559.     bool modify_label(){
  1560.         int d=INF;
  1561.         for(int u=0;u<N;u++){
  1562.             if(vis[u])
  1563.             for(int i=head[u];i!=-1;i=edge[i].next){
  1564.                 int v=edge[i].to;
  1565.                 if(edge[i].cap>edge[i].flow && !vis[v])
  1566.                     d=min(d,dis[v]+edge[i].cost-dis[u]);
  1567.             }
  1568.         }
  1569.         if(d==INF) return false;
  1570.             for(int i=0;i<N;i++)
  1571.             if(vis[i]){
  1572.                 vis[i]=false;
  1573.                 dis[i]+=d;
  1574.             }
  1575.         return true;
  1576.     }
  1577.     pair < int , int > mincostmaxflow(int start,int ed,int n ){
  1578.         ss=start,tt=ed,N=n;
  1579.         min_cost=max_flow=0;
  1580.         for(int i=0;i<n;i++) dis[i]=0;
  1581.         while(1){
  1582.             for(int i=0;i<n;i++) cur[i]=head[i];
  1583.             while(1){
  1584.                 for(int i=0;i<n;i++) vis[i]=false;
  1585.                 int tmp=aug(ss,INF);
  1586.                 if(tmp==0) break;
  1587.                 max_flow+=tmp;
  1588.                 min_cost+=tmp*dis[ss];
  1589.             }
  1590.             if(!modify_label()) break;
  1591.         }
  1592.         return mp( max_flow , min_cost );
  1593.     }
  1594. }solver;
  1595. ////////////////////////另外一种
  1596. const int inf = 1e9;
  1597. const int MAXN = 10000;
  1598. const int MAXM = 100000;
  1599. const int INF = 0x3f3f3f3f;
  1600. struct Edge
  1601. {
  1602.     int to, next, cap, flow, cost;
  1603.     int x, y;
  1604. } edge[MAXM],HH[MAXN],MM[MAXN];
  1605. int head[MAXN],tol;
  1606. int pre[MAXN],dis[MAXN];
  1607. bool vis[MAXN];
  1608. int N, M;
  1609. char map[MAXN][MAXN];
  1610. void init()
  1611. {
  1612.     N = MAXN;
  1613.     tol = 0;
  1614.     memset(head, -1, sizeof(head));
  1615. }
  1616. void addedge(int u, int v, int cap, int cost)//左端点，右端点，容量，花费
  1617. {
  1618.     edge[tol]. to = v;
  1619.     edge[tol]. cap = cap;
  1620.     edge[tol]. cost = cost;
  1621.     edge[tol]. flow = 0;
  1622.     edge[tol]. next = head[u];
  1623.     head[u] = tol++;
  1624.     edge[tol]. to = u;
  1625.     edge[tol]. cap = 0;
  1626.     edge[tol]. cost = -cost;
  1627.     edge[tol]. flow = 0;
  1628.     edge[tol]. next = head[v];
  1629.     head[v] = tol++;
  1630. }
  1631. bool spfa(int s, int t)
  1632. {
  1633.     queue<int>q;
  1634.     for(int i = 0; i < N; i++)
  1635.     {
  1636.         dis[i] = INF;
  1637.         vis[i] = false;
  1638.         pre[i] = -1;
  1639.     }
  1640.     dis[s] = 0;
  1641.     vis[s] = true;
  1642.     q.push(s);
  1643.     while(!q.empty())
  1644.     {
  1645.         int u = q.front();
  1646.         q.pop();
  1647.         vis[u] = false;
  1648.         for(int i = head[u]; i != -1; i = edge[i]. next)
  1649.         {
  1650.             int v = edge[i]. to;
  1651.             if(edge[i]. cap > edge[i]. flow &&
  1652.                     dis[v] > dis[u] + edge[i]. cost )
  1653.             {
  1654.                 dis[v] = dis[u] + edge[i]. cost;
  1655.                 pre[v] = i;
  1656.                 if(!vis[v])
  1657.                 {
  1658.                     vis[v] = true;
  1659.                     q.push(v);
  1660.                 }
  1661.             }
  1662.         }
  1663.     }
  1664.     if(pre[t] == -1) return false;
  1665.     else return true;
  1666. }
  1667. //返回的是最大流， cost存的是最小费用
  1668. int minCostMaxflow(int s, int t, int &cost)
  1669. {
  1670.     int flow = 0;
  1671.     cost = 0;
  1672.     while(spfa(s,t))
  1673.     {
  1674.         int Min = INF;
  1675.         for(int i = pre[t]; i != -1; i = pre[edge[i^1]. to])
  1676.         {
  1677.             if(Min > edge[i]. cap - edge[i]. flow)
  1678.                 Min = edge[i]. cap - edge[i]. flow;
  1679.         }
  1680.         for(int i = pre[t]; i != -1; i = pre[edge[i^1]. to])
  1681.         {
  1682.             edge[i]. flow += Min;
  1683.             edge[i^1]. flow -= Min;
  1684.             cost += edge[i]. cost * Min;
  1685.         }
  1686.         flow += Min;
  1687.     }
  1688.     return flow;
  1689. }
  1691. SBT
  1692. struct SBT{
  1694.     const static int maxn = 1e5 + 15;
  1696.     int lft[maxn] , rht[maxn] , key[maxn] , s[maxn] , tot , root ;
  1698.     void init(){ tot = root = 0 ; }
  1700.     void init( int x , int val = 0 ){
  1701.         lft[x] = rht[x] = 0 , key[x] = val , s[x] = 1;
  1702.     }
  1704.     inline void up(int x){
  1705.         s[x] = s[lft[x]] + s[rht[x]] + 1;
  1706.     }
  1708.     void lr(int &t){
  1709.         int k = rht[t];
  1710.         rht[t] = lft[k];
  1711.         lft[k] = t;
  1712.         s[k] = s[t];
  1713.         up(t);
  1714.         t = k;
  1715.     }
  1717.     void rr(int &t){
  1718.         int k = lft[t];
  1719.         lft[t] = rht[k];
  1720.         rht[k]= t;
  1721.         s[k] = s[t];
  1722.         up(t);
  1723.         t = k;
  1724.     }
  1726.     void Maintain(int &t,bool dir){
  1727.         if(dir == false){
  1728.             if(s[lft[lft[t]]] > s[rht[t]])
  1729.                 rr(t);
  1730.             else if(s[rht[lft[t]]] > s[rht[t]]){
  1731.                 lr(lft[t]);
  1732.                 rr(t);
  1733.             }
  1734.             else return;
  1735.         }
  1736.         else{
  1737.             if(s[rht[rht[t]]] > s[lft[t]]) lr(t);
  1738.             else if(s[lft[rht[t]]] > s[lft[t]]){
  1739.                 rr(rht[t]);
  1740.                 lr(t);
  1741.             }
  1742.             else return;
  1743.         }
  1744.         Maintain(lft[t],false);
  1745.         Maintain(rht[t],true);
  1746.         Maintain(t,true);
  1747.         Maintain(t,false);
  1748.     }
  1750.     void Insert( int & t , int val ){
  1751.         if( t == 0 ){
  1752.             t = ++ tot;
  1753.             init( t , val );
  1754.         }else{
  1755.             ++ s[t];
  1756.             if( val < key[t] ) Insert( lft[t] , val );
  1757.             else Insert( rht[t] , val );
  1758.             Maintain( t , val >= key[t] );
  1759.         }
  1760.     }
  1762.     // 删除操作必须保证元素存在
  1763.     int Delete(int &t , int v){
  1764.         int ret = 0;
  1765.         s[t] --;
  1766.         if((v == key[t]) || (v<key[t] && lft[t]  == 0) ||(v > key[t] && rht[t] == 0) ){
  1767.             ret = key[t];
  1768.             if(lft[t] == 0 || rht[t] == 0) t = lft[t] + rht[t];
  1769.             else key[t]  = Delete(lft[t],key[t] + 1);
  1770.         }
  1771.         else{
  1772.             if(v < key[t]) ret = Delete(lft[t] , v);
  1773.             else ret = Delete(rht[t] , v);
  1774.         }
  1775.         return ret;
  1776.     }
  1778.     bool find( int t , int val ){
  1779.         if( t == 0 ) return false;
  1780.         else if( key[t] == val ) return true;
  1781.         else if( val < key[t] ) return find( lft[t] , val );
  1782.         else return find( rht[t] , val );
  1783.     }
  1785.     void preorder( int x ){
  1786.         if( lft[x] ) preorder( lft[x] );
  1787.         printf("%d " , key[x]);
  1788.         if( rht[x] ) preorder( rht[x] );
  1789.     }
  1791.     int size(){
  1792.         return s[root];
  1793.     }
  1794.     // 查第 k 小 , 必须保证合法
  1795.     int kth( int x , int k ){
  1796.         if( k == s[lft[x]] + 1 ) return key[x];
  1797.         else if( k <= s[lft[x]] ) return kth( lft[x] , k );
  1798.         else return kth( rht[x] , k - s[lft[x]] - 1 );
  1799.     }
  1801.     //找前驱
  1802.     int pred( int t , int v ){
  1803.         if( t == 0 ) return v;
  1804.         else{
  1805.             if( v <= key[t] ) return pred( lft[t] , v );
  1806.             else{
  1807.                 int ans =  pred( rht[t] , v );
  1808.                 if( ans == v ) ans = key[t];
  1809.                 return ans;
  1810.             }
  1811.         }
  1812.     }
  1814.     // 严格小于 v 的有多少个
  1815.     int less( int t , int v ){
  1816.         if( t == 0 ) return 0;
  1817.         if( v <= key[t] ) return less( lft[t] , v );
  1818.         else return s[lft[t]] + 1 + less( rht[t] , v );
  1819.     }
  1821.     //找后继
  1822.     int succ( int t , int v ){
  1823.         if( t == 0 ) return v;
  1824.         else{
  1825.             if( v >= key[t] ) return succ( rht[t] , v );
  1826.             else{
  1827.                 int ans =  succ( lft[t] , v );
  1828.                 if( ans == v ) ans = key[t];
  1829.                 return ans;
  1830.             }
  1831.         }
  1832.     }
  1834. }sbt;
  1836. 行列式
  1838. int Det(){
  1839.     int cur = 0 , sgn = 1;
  1840.     for( int i = 0 ; i < N ; ++ i){
  1841.         int nxt = -1;
  1842.         for( int j = cur ; j < N ; ++ j) if( mat[j][i]){
  1843.             nxt = j ;
  1844.             break ;
  1845.         }
  1846.         if( nxt == -1 ) return 0;
  1847.         if( nxt != cur ) sgn = - sgn;
  1848.         for( int j = 0 ; j < N ; ++ j) swap( mat[cur][j] , mat[nxt][j] );
  1849.         for( int j = cur + 1 ; j < N ; ++ j){
  1850.             while( mat[j][i] ){
  1851.                 int x = mat[j][i] / mat[cur][i];
  1852.                 if( x ){
  1853.                     for( int k = i ; k < N ; ++ k){
  1854.                         mat[j][k] -= mul( mat[cur][k] , x ) ;
  1855.                         Maintain(mat[j][k]);
  1856.                     }
  1857.                 }else{
  1858.                     for( int k = i ; k < N ; ++ k) swap( mat[j][k] , mat[cur][k] );
  1859.                     sgn = - sgn;
  1860.                 }
  1861.             }
  1862.         }
  1863.         ++ cur;
  1864.     }
  1865.     int ans = 1;
  1866.     for( int i = 0 ; i < N ; ++ i ) ans = mul( ans , mat[i][i] );
  1867.     if( sgn == -1 ) ans = P - ans;
  1868.     return ans;
  1869. }
  1871. double Det(){
  1872.     //-- N;
  1873.     double ans = 1;
  1874.     int cur = 0 , sgn = 1;
  1875.     for(int i = 0 ; i < N ; ++ i){
  1876.         int nxt = -1;
  1877.         for( int j = cur ; j < N ; ++ j) if( fabs(mat[j][i]) > eps ){
  1878.             nxt = j ;
  1879.             break ;
  1880.         }
  1881.         if( nxt == -1 ) continue;
  1882.         for( int j = 0 ; j < N ; ++ j) swap( mat[cur][j] , mat[nxt][j] );
  1883.         if( nxt != cur ) sgn = - sgn;
  1884.         for( int j = 0 ; j < N ; ++ j ) if( j != cur ){
  1885.             double s = mat[j][i] / mat[cur][i];
  1886.             for( int k = i ; k < N ; ++ k) mat[j][k] -= s * mat[cur][k];
  1887.         }
  1888.         ++ cur ;
  1889.     }
  1890.     for( int i = 0 ; i < N ; ++ i) ans = ans * mat[i][i];
  1891.     return ans * sgn;
  1892. }

uestc_retarded 模板的更多相关文章

  1. Jade模板引擎让你飞

    写在前面:现在jade改名成pug了 一.安装 npm install jade 二.基本使用 1.简单使用 p hello jade! 渲染后: <p>hello jade!</p ...

  2. ABP入门系列（2）——通过模板创建MAP版本项目

    一.从官网创建模板项目 进入官网下载模板项目 依次按下图选择: 输入验证码开始下载 下载提示: 二.启动项目 使用VS2015打开项目,还原Nuget包: 设置以Web结尾的项目,设置为启动项目: 打 ...

  3. CMS模板应用调研问卷

    截止目前,已经有数十家网站与我们合作,进行了MIP化改造,在搜索结果页也能看到"闪电标"的出现.除了改造方面的问题,MIP项目组被问到最多的就是:我用了wordpress,我用了织 ...

  4. PHP-自定义模板-学习笔记

    1.  开始 这几天,看了李炎恢老师的<PHP第二季度视频>中的“章节7:创建TPL自定义模板”,做一个学习笔记,通过绘制架构图.UML类图和思维导图,来对加深理解. 2.  整体架构图 ...

  5. 【原创分享·微信支付】C# MVC 微信支付之微信模板消息推送

    微信支付之微信模板消息推送                    今天我要跟大家分享的是“模板消息”的推送,这玩意呢,你说用途嘛,那还是真真的牛逼呐.原因在哪?就是因为它是依赖微信生存的呀,所以他能不 ...

  6. OpenCV模板匹配算法详解

    1 理论介绍 模板匹配是在一幅图像中寻找一个特定目标的方法之一,这种方法的原理非常简单,遍历图像中的每一个可能的位置,比较各处与模板是否“相似”,当相似度足够高时,就认为找到了我们的目标.OpenCV ...

  7. 前端MVC学习总结（一）——MVC概要与angular概要、模板与数据绑定

    一.前端MVC概要 1.1.库与框架的区别 框架是一个软件的半成品,在全局范围内给了大的约束.库是工具,在单点上给我们提供功能.框架是依赖库的.AngularJS是框架而jQuery则是库. 1.2. ...

  8. ThinkPHP+Smarty模板中截取包含中英文混合的字符串乱码的解决方案

    好几天没写博客了,其实有好多需要总结的,因为最近一直在忙着做项目,但是困惑了几天的Smarty模板中截取包含中英文混合的字符串乱码的问题,终于解决了,所以记录下来,需要的朋友看一下: 出现乱码的原因: ...

  9. ThinkPHP 模板substr的截取字符串函数

    ThinkPHP 模板substr的截取字符串函数在Common/function.php加上以下代码 /** ** 截取中文字符串 **/ function msubstr($str, $start ...

随机推荐

  1. win10使用Composer-Setup安装Composer以及使用Composer安装Yii2最新版

    1:下载 ca-bundle.crt和cacert.pem 将这两个文件放在php目录下 2:php.ini中添加上述两个文件的路径 curl.cainfo=C:/xampp/php/ca-bundl ...

  2. <改变未来的九大算法>读书笔记二

    原理 数据库的一致性 1.事务和代办事项表把戏(预写日志记录) 1.代办事项表把戏:先把要执行的的操作写入硬件,即写日志.即使数据库操作错误,也可根据日志来纠正.对日志的操作具有等幂性,即日志中的每项 ...

  3. Xcode7.2 导入XMPP框架错误解决

    1.修改Build Settings 在 Header Search Paths 中添加: "/usr/include/libxml2" 在Other Linker Flags 中 ...

  4. ubuntu搭建svn服务器（转）

    在阿里云买了个服务器,想上传东西,samba不好用,想起来可以搭个svn用,找到了这篇. 1. 安装SVN apt-get install subversion 2. 建立svn仓库 1). 建立sv ...

  5. java后台开发传输乱码&&接口post传参失败

    起因: 前几天遇到的问题,才有时间记录,需求:本地生成xml形式的字符串以参数形式用post方法传送到对方的固定接口: 这个需求写的时候感觉很容易,本地测试的时候,也觉得很简单就过了,然后和对方联调的 ...

  6. php redis 代码实例

    <?phpheader("Content-type:text/html;charset=utf8");$redis = new redis();$redis ->con ...

  7. HTTP02--Http请求头及缓存知识

    一.常用工具 Linux下:curl命令,I参数可以查看http head信息. Firefox:Firebug.HttpFox 二.常见Http Head信息 三.浏览器缓存机制 使用ctrl+F5 ...

  8. ASP.NET Core 源码阅读笔记(5) ---Microsoft.AspNetCore.Routing路由

    这篇随笔讲讲路由功能,主要内容在项目Microsoft.AspNetCore.Routing中,可以在GitHub上找到,Routing项目地址. 路由功能是大家都很熟悉的功能,使用起来也十分简单,从 ...

  9. C#自学系列 - 开篇

    2014年即将过去,这一年我参加了不少面试,被问到了很多问题.回来总结下发现自己确实在基础方面有着很多的不足,还有很多东西是我不知道的.遂在下半年购入书籍若干,并系统的加以学习.我目前在看的书是Jon ...

  10. [芯片] 4、接口技术·实验四·串行接口8251A

    目录 一.实验目的和要求... 2 二.实验原理与背景... 3 三.实验具体的内容... 3 四.实验的代码说明... 4 五.实验结果的分析... 6 附录资料 一.实验目的和要求 学会8251芯 ...