$$2019中国大学生程序设计竞赛（CCPC）\ -\ 网络选拔赛$$

\(A.\hat{} \& \hat{}\)

签到，只把AB都有的位给异或掉

  1. //#pragma comment(linker, "/STACK:1024000000,1024000000")
  2. #include<bits/stdc++.h>
  3. using namespace std;
  4. function<void(void)> ____ = [](){ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);};
  5. using LL = int_fast64_t;
  6. int main(){
  7.     LL T,a,b;
  8.     ____();
  9.     cin >> T;
  10.     while(T--){
  11.         cin >> a >> b;
  12.         cout << ((a&b)==0?1:(a&b)) << endl;
  13.     }
  14.     return 0;
  15. }

\(B.array\)

给出一个排列（1~n各出现一次），有两种操作：

1、把其中一个数加上1e7

2、问区间\(1\)~\(r\)中不小于\(k\)且没有在区间内出现过的最小的数是多少

对于第一种操作，由于\(k\le n\)，所以给一个数加上1e7相当于把这个数删了，所以第一个操作相当于删除这个数

对于第二种操作，首先判断区间内存不存在\(k\)，不存在则直接输出\(k\)，如果存在的话，就找区间内从\(k\)开始的最长连续串，这个可以二分连续串长度，然后先判断其中有点被删除了，没有的话用主席树判断是否所有点都在1~\(r\)的区间内

  1. //#pragma comment(linker, "/STACK:1024000000,1024000000")
  2. #include<bits/stdc++.h>
  3. using namespace std;
  4. function<void(void)> ____ = [](){ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);};
  5. const int MAXN = 1e5+7;
  6. const int INF = 0x3f3f3f3f;
  7. int T,n,m,A[MAXN],rp[MAXN];
  8. struct BinaryIndexed_Tree{
  9.     int val[MAXN];
  10.     #define lowbit(x) (x&(-x))
  11.     void init(){ memset(val,0,sizeof(val)); }
  12.     void update(int pos){
  13.         while(pos<=n){
  14.             val[pos]++;
  15.             pos += lowbit(pos);
  16.         }
  17.     }
  18.     int query(int pos){
  19.         int res = 0;
  20.         while(pos){
  21.             res += val[pos];
  22.             pos -= lowbit(pos);
  23.         }
  24.         return res;
  25.     }
  26. }BIT;
  27. struct PersistentSegmentTree{
  28.     int tot,sum[MAXN<<5],ls[MAXN<<5],rs[MAXN<<5],root[MAXN];
  29.     void update(int &now, int pre, int L, int R, int pos){
  30.         now = ++tot;
  31.         ls[now] = ls[pre];
  32.         rs[now] = rs[pre];
  33.         sum[now] = sum[pre] + 1;
  34.         if(L+1==R) return;
  35.         int mid = (L+R) >> 1;
  36.         if(pos < mid) update(ls[now],ls[pre],L,mid,pos);
  37.         else update(rs[now],rs[pre],mid,R,pos);
  38.     }
  39.     void build(){
  40.         tot = 0;
  41.         for(int i = 1; i <= n; i++) update(root[i],root[i-1],1,n+1,A[i]);
  42.     }
  43.     int _kth(int lo, int ro, int L, int R, int k){
  44.         if(L+1==R) return L;
  45.         int lsz = sum[ls[ro]] - sum[ls[lo]];
  46.         int mid = (L+R) >> 1;
  47.         if(k<=lsz) return _kth(ls[lo],ls[ro],L,mid,k);
  48.         else return _kth(rs[lo],rs[ro],mid,R,k-lsz);
  49.     }
  50.     int _rk(int lo, int ro, int L, int R, int x){
  51.         if(L+1==R) return 1;
  52.         int mid = (L+R) >> 1;
  53.         if(x<mid) return _rk(ls[lo],ls[ro],L,mid,x);
  54.         else return sum[ls[ro]]-sum[ls[lo]] + _rk(rs[lo],rs[ro],mid,R,x);
  55.     }
  56.     int kth(int L, int R, int k){ return _kth(root[L-1],root[R],1,n+1,k); }
  57.     int rk(int L, int R, int x){ return _rk(root[L-1],root[R],1,n+1,x); }
  58. }PST;
  59. inline int read(){
  60.     int x = 0, f = 1;
  61.     char c = getchar();
  62.     while(c!='-'&&(c<'0'||c>'9')) c = getchar();
  63.     if(c=='-') f = -1,c = getchar();
  64.     while(c>='0'&&c<='9') x = x*10+c-'0', c = getchar();
  65.     return f*x;
  66. }
  67. void work(){
  68.     n = read(), m = read();
  69.     for(int i = 1; i <= n; i++){
  70.         A[i] = read();
  71.         rp[A[i]] = i;
  72.     }
  73.     PST.build();
  74.     BIT.init();
  75.     int lastans = 0;
  76.     for(int i = 1; i <= m; i++){
  77.         int op = read();
  78.         if(op==1){
  79.             int pos = read();
  80.             pos ^= lastans;
  81.             if(rp[A[pos]]!=INF){
  82.                 BIT.update(A[pos]);
  83.                 rp[A[pos]] = INF;
  84.             }
  85.         }
  86.         else{
  87.             int lim = read(), x = read();
  88.             lim ^= lastans; x ^= lastans;
  89.             if(rp[x]>lim){
  90.                 printf("%d\n",lastans=x);
  91.                 continue;
  92.             }
  93.             int k = PST.rk(1,lim,x);
  94.             int l = 1, r = lim - k + 1;
  95.             while(l<=r){
  96.                 int mid = (l+r) >> 1;
  97.                 if(BIT.query(x+mid-1)-BIT.query(x-1)>0||PST.kth(1,lim,k+mid-1)!=x+mid-1) r = mid - 1;
  98.                 else l = mid + 1;
  99.             }
  100.             printf("%d\n",lastans=x+r);
  101.         }
  102.     }
  103. }
  104. int main(){
  105.     for(T = read(); T; T--) work();
  106.     return 0;
  107. }

\(C.K-th\ occurrence\)

给出一个字符串，给出\(m\)次询问，每次询问在字符串中第\(k\)次出现字串\(s_l~s_r\)的位置在哪

首先建出后缀数组和\(lcp\)，对于每次询问，首先找到符合答案条件的区间，可以二分+ST表做，然后在区间中找第\(k\)大即可，根据\(sa\)数组建主席树

  1. //#pragma comment(linker, "/STACK:1024000000,1024000000")
  2. #include<bits/stdc++.h>
  3. using namespace std;
  4. function<void(void)> ____ = [](){ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);};
  5. const int MAXN = 1e5+7;
  6. const int INF = 0x3f3f3f3f;
  7. int T,rk[MAXN],sa[MAXN],sec[MAXN],n,m,c[MAXN],lcp[MAXN],ST[MAXN][20];
  8. char s[MAXN];
  9. struct PersistentSegmentTree{
  10.     int tot,root[MAXN<<5],sum[MAXN<<5],ls[MAXN<<5],rs[MAXN<<5];
  11.     void insert(int &now, int pre, int L, int R, int pos){
  12.         now = ++tot;
  13.         ls[now] = ls[pre];
  14.         rs[now] = rs[pre];
  15.         sum[now] = sum[pre] + 1;
  16.         if(L+1==R) return;
  17.         int mid = (L+R) >> 1;
  18.         if(pos < mid) insert(ls[now],ls[pre],L,mid,pos);
  19.         else insert(rs[now],rs[pre],mid,R,pos);
  20.     }
  21.     void build(){
  22.         tot = 0;
  23.         for(int i = 1; i <= n; i++) insert(root[i],root[i-1],1,n+1,sa[i]);
  24.     }
  25.     int _query(int lo, int ro , int k, int L, int R){
  26.         if(L+1==R) return L;
  27.         int lsz = sum[ls[ro]] - sum[ls[lo]];
  28.         int mid = (L+R) >> 1;
  29.         if(k<=lsz) return _query(ls[lo],ls[ro],k,L,mid);
  30.         else return _query(rs[lo],rs[ro],k-lsz,mid,R);
  31.     }
  32.     int query(int L, int R, int k){
  33.         return _query(root[L-1],root[R],k,1,n+1);
  34.     }
  35. }PST;
  36. void SA(int M){
  37.     for(int i = 0; i <= M; i++) c[i] = 0;
  38.     for(int i = 1; i <= n; i++) c[rk[i]=s[i]]++;
  39.     for(int i = 1; i <= M; i++) c[i] += c[i-1];
  40.     for(int i = 1; i <= n; i++) sa[c[rk[i]]--] = i;
  41.     for(int k = 1; k <= n; k <<= 1){
  42.         int p = 0;
  43.         for(int i = n - k + 1; i <= n; i++) sec[++p] = i;
  44.         for(int i = 1; i <= n; i++) if(sa[i]>k) sec[++p] = sa[i]-k;
  45.         for(int i = 0 ; i <= M; i++) c[i] = 0;
  46.         for(int i = 1; i <= n; i++) c[rk[sec[i]]]++;
  47.         for(int i = 1; i <= M; i++) c[i] += c[i-1];
  48.         for(int i = n; i >= 1; i--) sa[c[rk[sec[i]]]--] = sec[i];
  49.         p = 1;
  50.         swap(rk,sec);
  51.         rk[sa[1]] = 1;
  52.         for(int i = 2; i <= n; i++) rk[sa[i]] = (sec[sa[i]]==sec[sa[i-1]]&&sec[sa[i]+k]==sec[sa[i-1]+k])?p:++p;
  53.         if(p==n) break;
  54.         M = p;
  55.     }
  56. }
  57. void Getlcp(){
  58.     int k = 0;
  59.     for(int i = 1; i <= n; i++){
  60.         if(k) k--;
  61.         int j = sa[rk[i]-1];
  62.         while(s[i+k]==s[j+k]) k++;
  63.         lcp[rk[i]] = k;
  64.     }
  65. }
  66. void buildST(){
  67.     for(int i = 1; i <= n; i++) ST[i][0] = lcp[i];
  68.     for(int k = 1; (1<<k) <= n; k++){
  69.         for(int i = 1; (i+(1<<k))-1 <= n; i++){
  70.             ST[i][k] = min(ST[i][k-1],ST[i+(1<<(k-1))][k-1]);
  71.         }
  72.     }
  73. }
  74. int qmin(int l, int r){
  75.     if(l>r) return -1;
  76.     int d = log2(r-l+1);
  77.     return min(ST[l][d],ST[r-(1<<d)+1][d]);
  78. }
  79. void work(){
  80.     scanf("%d %d",&n,&m);
  81.     scanf("%s",s+1);
  82.     SA(256);
  83.     Getlcp();
  84.     buildST();
  85.     PST.build();
  86.     while(m--){
  87.         int L, R, k, st, ed;
  88.         scanf("%d %d %d",&L,&R,&k);
  89.         int d = R - L + 1;
  90.         int pos = rk[L];
  91.         int l = 1, r = pos;
  92.         while(l<=r){
  93.             int mid = (l+r) >> 1;
  94.             if(qmin(pos-mid+1,pos)>=d) l = mid + 1;
  95.             else r = mid - 1;
  96.         }
  97.         st = pos - r;
  98.         l = 1, r = n - pos;
  99.         while(l<=r){
  100.             int mid = (l+r) >> 1;
  101.             if(qmin(pos+1,pos+mid)>=d) l = mid + 1;
  102.             else r = mid - 1;
  103.         }
  104.         ed = pos + r;
  105.         if(st+k-1>ed) printf("-1\n");
  106.         else printf("%d\n",PST.query(st,ed,k));
  107.     }
  108. }
  109. int main(){
  110.     for(scanf("%d",&T);T;T--) work();
  111.     return 0;
  112. }

\(D.path\)

要求全局路径\(k\)短路，做法类似堆优化的\(Dijkstra\)，每次取队列首元素\(pop\)，然后这是第几次\(pop\)的就是第几短路，然后用这个点扩展其他路径，加入优先队列中。

发现每次把所有连边都加进去的话内存消耗会非常大，可能队列中出一个点然后加进去很多点，所以需要优化一下，把一些无用点不加进去，考虑当前队列长度如果大于\(k\)，那么队尾的元素都可以删掉了，直到长度为\(k\)，这些点必然不会构成\(k\)短路，但是这样还是要遍历每条邻边。考虑把一个点所连的所有边按长度排序，如果队列已满并且当前点的距离+边的距离比队尾元素还大，那么之后的边就都不用加进去了，否则就用新的点替换队尾的点。

  1. //#pragma comment(linker, "/STACK:1024000000,1024000000")
  2. #include<bits/stdc++.h>
  3. using namespace std;
  4. function<void(void)> ____ = [](){ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);};
  5. const int MAXN = 5e4+7;
  6. using LL = int_fast64_t;
  7. vector<pair<int,int>> G[MAXN];
  8. int T,n,m,q,query[MAXN],cnt;
  9. set<pair<pair<LL,int>,int>> S;
  10. void solve(){
  11.     scanf("%d %d %d",&n,&m,&q);
  12.     for(int i = 1; i <= n; i++) G[i].clear();
  13.     for(int i = 1; i <= m; i++){
  14.         int u, v, c;
  15.         scanf("%d %d %d",&u,&v,&c);
  16.         G[u].emplace_back(make_pair(v,c));
  17.     }
  18.     for(int i = 1; i <= n; i++) sort(G[i].begin(),G[i].end(),[](const pair<int,int> &A, const pair<int,int> &B){
  19.         return A.second < B.second;
  20.     });
  21.     for(int i = 1; i <= q; i++) scanf("%d",&query[i]);
  22.     int maxx = *max_element(query+1,query+1+q), tag = 0;
  23.     S.clear();
  24.     for(int u = 1; u <= n; u++) for(auto e : G[u]) S.insert(make_pair(make_pair(e.second,e.first),tag++));
  25.     vector<LL> res;
  26.     while(maxx){
  27.         auto p = S.begin()->first;
  28.         S.erase(S.begin());
  29.         res.emplace_back(p.first);
  30.         while((int)S.size()>maxx) S.erase(--S.end());
  31.         for(auto e : G[p.second]){
  32.             if((int)S.size()<maxx) S.insert(make_pair(make_pair(p.first+e.second,e.first),tag++));
  33.             else{
  34.                 if(p.first+e.second>=S.rbegin()->first.first) break;
  35.                 else{
  36.                     S.erase(--S.end());
  37.                     S.insert(make_pair(make_pair(p.first+e.second,e.first),tag++));
  38.                 }
  39.             }
  40.         }
  41.         maxx--;
  42.     }
  43.     for(int i = 1; i <= q; i++) printf("%I64d\n",res[query[i]-1]);
  44. }
  45. int main(){
  46.     for(scanf("%d",&T); T; T--) solve();
  47.     return 0;
  48. }

\(E.huntian\ oy\)

杜教筛+欧拉函数

定义函数\(f(n,a,b)=\sum^{n}_{i=1}\sum^{i}_{j=1}gcd(i^a-j^a,i^b-j^b)[gcd(i,j)=1]%1e9+7\)其中\(a\)和\(b\)互质,求值

根据某定理，当\(a\)和\(b\)互质的情况下，\(gcd(i^a-j^a,i^b-j^b)=i-j\)

然后原函数就变成了\(f(n,a,b)=\sum^{n}_{i=1}\sum^{i}_{j=1}(i-j)[gcd(i,j)=1]\)

拆分之后得到：\(f(n,a,b)=\sum^{n}_{i=1}i·\sum^{i}_{j=1}[gcd(i,j)=1]+\sum^{n}_{i=1}\sum^{i}_{j=1}j·[gcd(i,j)=1]\)

观察到前面求和的是\(i\)乘上比\(i\)小的和\(i\)互质的数的个数，后面求和的是比\(i\)小的和\(i\)互质的数的和，转换为欧拉函数的表达式：

\[f(n,a,b)=\sum^{n}_{i=1}i·\phi(i)-\sum^{n}_{i=1}\frac{i·\phi(i)+[i=1]}{2}
\]
\[=\sum^{n}_{i=1}\frac{i·\phi(i)}{2}-\frac{1}{2}=\frac{(\sum^{n}_{i=1}i·\phi(i))-1}{2}
\]

接下来令\(f(i)=i·\phi(i)\)，用杜教筛求和

\[\sum_{i=1}^{n}(f*ID)(i)=\sum_{i=1}^{n}\sum_{d|i}f(\frac{i}{d})ID(d)
\]
\[=\sum_{i=1}^{n}\sum_{j=1}^{\frac{n}{i}}ID(i)f(j)=\sum_{i=1}^{n}ID(i)S(\frac{n}{i})
\]
\[\Rightarrow ID(1)S(n)=\sum_{i=1}^{n}(f*ID)(i)-\sum_{i=2}^{n}ID(i)S(\frac{n}{i})
\]
\[\Rightarrow S(n)=\sum_{i=1}^{n}(f*ID)(i)-\sum_{i=2}^{n}i·S(\frac{n}{i})
\]

接下来计算一下\(\sum^{n}_{i=1}(f*ID)(i)\)

\[\sum^{n}_{i=1}(f*ID)(i)=\sum^{n}_{i=1}\sum_{d|i}\phi(\frac{i}{d})·\frac{i}{d}·d=\sum^{n}_{i=1}i·\sum_{d|i}\phi(d)=\sum^{n}_{i=1}i·(\phi*1)(i)=\sum^{n}_{i=1}i·ID(i)=\sum^{n}_{i=1}i^2
\]
\[\because \sum_{i=1}^{n}i^2=\frac{n(n+1)(2n+1)}{6}
\]
\[\therefore S(n)=\frac{n(n+1)(2n+1)}{6}-\sum_{i=2}^{n}i·S(n/i)
\]

用杜教筛即可

  1. //#pragma comment(linker, "/STACK:1024000000,1024000000")
  2. #include<bits/stdc++.h>
  3. using namespace std;
  4. function<void(void)> ____ = [](){ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);};
  5. using LL = int_fast64_t;
  6. const int MAXN = 3e6+7;
  7. const LL MOD = 1e9+7;
  8. const LL INV2 = 500000004;
  9. const LL INV6 = 166666668;
  10. int T,tot,n,a,b;
  11. LL phi[MAXN],siphi[MAXN];
  12. unordered_map<LL,LL> mpsiphi;
  13. int prime[MAXN];
  14. void linear_sieve(){
  15.     phi[1] = 1;
  16.     for(int i = 2; i < MAXN; i++){
  17.         if(!phi[i]){
  18.             phi[i] = i-1;
  19.             prime[tot++] = i;
  20.         }
  21.         for(int j = 0; j < tot; j++){
  22.             if(i*prime[j]>=MAXN) break;
  23.             if(i%prime[j]) phi[i*prime[j]] = phi[i] * phi[prime[j]];
  24.             else{
  25.                 phi[i*prime[j]] = phi[i] * prime[j];
  26.                 break;
  27.             }
  28.         }
  29.     }
  30.     for(int i = 1; i < MAXN; i++) siphi[i] = (siphi[i-1]+phi[i]*i)%MOD;
  31. }
  32. LL getsiphi(LL x){
  33.     if(x<MAXN) return siphi[x];
  34.     if(mpsiphi.count(x)) return mpsiphi.at(x);
  35.     LL res = INV6 * x % MOD * (x+1) % MOD * (2*x+1) % MOD;
  36.     for(LL i = 2, j; i <= x; i = j + 1){
  37.         j = x/(x/i);
  38.         res = ((res-(i+j)*(j-i+1)/2%MOD*getsiphi(x/i))%MOD+MOD)%MOD;
  39.     }
  40.     return mpsiphi[x] = res;
  41. }
  42. void solve(){
  43.     scanf("%d %d %d",&n,&a,&b);
  44.     printf("%I64d\n",(getsiphi(n)-1+MOD)*INV2%MOD);
  45. }
  46. int main(){
  47.     linear_sieve();
  48.     for(scanf("%d",&T); T; T--) solve();
  49.     return 0;
  50. }

\(F.Shuffl Card\)

给一个序列，每次取出其中一个数放到最前面，问最终序列

只考虑每个最后一次放到前面的数，如果没有被放到前面过就按顺序在最后输出

  1. //#pragma comment(linker, "/STACK:1024000000,1024000000")
  2. #include<bits/stdc++.h>
  3. using namespace std;
  4. function<void(void)> ____ = [](){ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);};
  5. const int MAXN = 1e5+7;
  6. int n,m,A[MAXN],vis[MAXN],B[MAXN];
  7. int main(){
  8.     while(scanf("%d %d",&n,&m)!=EOF){
  9.         for(int i = 1; i <= n; i++) scanf("%d",&A[i]);
  10.         queue<int> que;
  11.         for(int i = 1; i <= m; i++) scanf("%d",&B[i]);
  12.         for(int i = m; i >= 1; i--){
  13.             if(vis[B[i]]) continue;
  14.             que.push(B[i]);
  15.             vis[B[i]] = true;
  16.         }
  17.         for(int i = 1; i <= n; i++) if(!vis[A[i]]) que.push(A[i]);
  18.         while(!que.empty()){
  19.             printf("%d ",que.front());
  20.             que.pop();
  21.         }
  22.     }
  23.     return 0;
  24. }

\(G.Windows\ Of\ CCPC\)

签到，递归构造即可

  1. //#pragma comment(linker, "/STACK:1024000000,1024000000")
  2. #include<bits/stdc++.h>
  3. using namespace std;
  4. function<void(void)> ____ = [](){ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);};
  5. int t,k;
  6. char s[1111][1111];
  7. void solve(int x, int y, char C, char P, int kk){
  8.     if(kk==1){
  9.         s[x][y] = C;
  10.         s[x][y+1] = C;
  11.         s[x+1][y+1] = C;
  12.         s[x+1][y] = P;
  13.         return;
  14.     }
  15.     int gap = (1<<(kk-1));
  16.     solve(x,y,C,P,kk-1);
  17.     solve(x+gap,y+gap,C,P,kk-1);
  18.     solve(x,y+gap,C,P,kk-1);
  19.     solve(x+gap,y,P,C,kk-1);
  20. }
  21. int main(){
  22.     scanf("%d",&t);
  23.     while(t--){
  24.         scanf("%d",&k);
  25.         memset(s,0,sizeof(s));
  26.         solve(1,1,'C','P',k);
  27.         for(int i = 1; i <= (1<<k); i++) printf("%s\n",s[i]+1);
  28.     }
  29.     return 0;
  30. }

\(H.Fishing\ Master\)

首先第一次捕的时间是必须要用上的，然后每次最好利用煮的时间去捕，而且回来的时候还没有煮熟。

如果到最后一定要浪费掉捕的时间（也就是在捕的时候，已经煮熟了），那就要选\(%k\)余数大的，这样浪费的时间就能更少

  1. //#pragma comment(linker, "/STACK:1024000000,1024000000")
  2. #include<bits/stdc++.h>
  3. using namespace std;
  4. function<void(void)> ____ = [](){ios_base::sync_with_stdio(false); cin.tie(0); cout.tie(0);};
  5. const int MAXN = 1e5+7;
  6. using LL = int_fast64_t;
  7. int T,n,k,A[MAXN];
  8. void solve(){
  9.     scanf("%d %d",&n,&k);
  10.     LL res = k,s = 0;
  11.     for(int i = 1; i <= n; i++){
  12.         scanf("%d",&A[i]);
  13.         s += A[i]/k;
  14.         res += A[i];
  15.     }
  16.     if(s<n-1){
  17.         sort(A+1,A+1+n,[](const int &x, const int &y){ return x%k > y%k; });
  18.         for(int i = 1; i <= n-1-s; i++) res += k-A[i]%k;
  19.     }
  20.     printf("%I64d\n",res);
  21. }
  22. int main(){
  23.     for(scanf("%d",&T); T; T--) solve();
  24.     return 0;
  25. }

\(I.Kaguya\)

\(J.Touma\ Kazusa's\ function\)

\(K.sakura\)

2019中国大学生程序设计竞赛（CCPC） - 网络选拔赛（8/11）的更多相关文章

  1. [BFS,A*,k短路径] 2019中国大学生程序设计竞赛（CCPC） - 网络选拔赛 path (Problem - 6705)

    题目:http://acm.hdu.edu.cn/showproblem.php?pid=6705 path Time Limit: 2000/2000 MS (Java/Others)    Mem ...

  2. [贪心,dp] 2019中国大学生程序设计竞赛（CCPC） - 网络选拔赛 Fishing Master (Problem - 6709)

    题目:http://acm.hdu.edu.cn/showproblem.php?pid=6709 Fishing Master Time Limit: 2000/1000 MS (Java/Othe ...

  3. 【赛后总结+部分题解】2019中国大学生程序设计竞赛（CCPC） - 网络选拔赛

    赛后总结: T:今天状态一般,甚至有点疲惫.然后12点比赛开始,和队友开始看题,从最后往前面看,发现数学题公式看不懂.然后发现队友已经双开做1001和1006了,我看着1007有人A,开始做1007. ...

  4. 2019中国大学生程序设计竞赛（CCPC） - 网络选拔赛

    传送门 A.^&^ 题意: 找到最小的正数\(C\),满足\((A\ xor\ C)\&(B\ xor \ C)\)最小. 思路: 输出\(A\&B\)即可,特判答案为0的情况 ...

  5. 2019中国大学生程序设计竞赛（CCPC） - 网络选拔赛 A题

    A - ^&^ Bit operation is a common computing method in computer science ,Now we have two positive ...

  6. 【2019中国大学生程序设计竞赛-女生专场】C - Function

    原题 韦神提供的思路orz 首先一个显然的性质,所有的c可以提出来,方程变成ax^2+bx的形式 因为x的值是离散的,而m的值又不大 所以一开始让x都为1(注意!x是正整数),然后每次挑一个x让他加一 ...

  7. 2019中国大学生程序设计竞赛-女生专场（重现赛）部分题解C-Function(贪心+优先队列) H-clock(模拟)

    Function 题目链接 Problem Description wls 有 n 个二次函数 Fi(x) = aix2 + bix + ci (1 ≤ i ≤ n). 现在他想在∑ni=1xi = ...

  8. 2016中国大学生程序设计竞赛 - 网络选拔赛 C. Magic boy Bi Luo with his excited tree

    Magic boy Bi Luo with his excited tree Problem Description Bi Luo is a magic boy, he also has a migi ...

  9. 2018中国大学生程序设计竞赛 - 网络选拔赛 1001 - Buy and Resell 【优先队列维护最小堆+贪心】

    题目传送门:http://acm.hdu.edu.cn/showproblem.php?pid=6438 Buy and Resell Time Limit: 2000/1000 MS (Java/O ...

随机推荐

  1. Java的nanoTime()方法

    java有两个获取和时间相关的秒数方法,一个是广泛使用的 System.currentTimeMillis() 返回的是从一个长整型结果,表示毫秒. 另一个是 System.nanoTime() 返回 ...

  2. PAT甲级练习 1087 All Roads Lead to Rome (30分) 字符串hash + dijkstra

    题目分析: 这题我在写的时候在PTA提交能过但是在牛客网就WA了一个点,先写一下思路留个坑 这题的简单来说就是需要找一条最短路->最开心->点最少(平均幸福指数自然就高了),由于本题给出的 ...

  3. 数学建模学习笔记 | matlab基本命令及用法

    前言 数学建模对matlab水平的要求 了解matlab的基本用法,如常用命令.脚本结构.矩阵的基本操作.绘图等: 熟悉matlab的程序结构,能创建和引用函数: 熟悉常见模型的求解算法和套路: 自主 ...

  4. python模块详解 | shutil

    简介: shutil是python的一个内置模块,提供了许多关于文件和文件集合的高级操作,特别提供文件夹与文件操作.归档操作了支持文件复制和删除的功能. 文件夹与文件操作: copyfileobj(f ...

  5. SQLI-LABS复现通关

    sql-lab 复现通关(深入学习) less-1 基于错误的单引号字符串 - 正常访问 127.0.0.1/?id=1 - 添加 ' 返回报错信息:You have an error in your ...

  6. 简单解析一下 Mybatis 常用的几个配置

    目录 核心配置文件 环境配置(environments) 属性(properties) 类型别名(typeAliases) 映射器(mappers) Mybatis 参考:https://mybati ...

  7. 【Oracle】删除表空间

    删除表空间如果是 SQL> DROP TABLEPSACE XXXX; 是无法将数据文件一同都删除的 想要删除表空间和数据文件需要如下操作: SQL> drop tablespace XX ...

  8. .NET 项目中的单元测试

    .NET 项目中的单元测试 Intro "不会写单元测试的程序员不是合格的程序员,不写单元测试的程序员不是优秀的工程师." -- 一只想要成为一个优秀程序员的渣逼程序猿. 那么问题 ...

  9. 忒修斯的Mac

    我有一台Mac笔记本,用了快6年了,当初买它的时候还借了几千块. 三年前,它的屏幕坏了,修理的方式就是直接换屏,而换屏其实就是上半部分连壳带屏幕整个换掉,简单的说:另一台电脑的上半身嫁接过来. 今年, ...

  10. 今天聊点干货—关于CSS样式来源

    样式来源 CSS样式共有5个来源,它们分别是\(\color{#FF3030}{浏览器默认样式}\).\(\color{#FF3030}{用户样式}\).\(\color{#FF3030}{链接样式} ...