The 2018 ACM-ICPC Asia Qingdao Regional Contest, Online Solution

最新推荐文章于 2020-12-11 14:26:35 发布
最新推荐文章于 2020-12-11 14:26:35 发布
阅读量135 收藏
点赞数
原文链接：http://www.cnblogs.com/Dup4/p/9657033.html
版权

A    Live Love

水。

 1 #include<bits/stdc++.h>
 2 
 3 using namespace std;
 4 
 5 typedef long long ll;
 6 const double eps = 1e-8;
 7 const int INF = 0x3f3f3f3f;
 8 const ll MOD = (int)1e9 + 7;
 9 const int maxn = (int)1e6 + 10;
10 
11 int n, m;
12 
13 inline void RUN()
14 {
15     int t;
16     scanf("%d", &t);
17     while (t--)
18     {
19         scanf("%d %d", &n, &m);
20         int ans1 = m;
21         int ans2 = (n) / (n - m + 1);
22         printf("%d %d\n", ans1, ans2);
23     }
24 }
25 
26 int main()
27 {
28 #ifdef LOCAL_JUDGE
29     freopen("Text.txt", "r", stdin);
30 #endif // LOCAL_JUDGE
31 
32     RUN();
33 
34 #ifdef LOCAL_JUDGE
35     fclose(stdin);
36 #endif // LOCAL_JUDGE
37     return 0;
38 }
View Code

 

B Red Black Tree

题意：有一个树，上面有红点和黑点，有边权，每个点的花费定义为它到离它最近的红点的距离，每次询问给出一些点，能够将这棵树中的一个黑点变为红点，使得这些点中的最大花费最小

思路：二分答案，符合条件的点不管，将不符合条件的点LCA求出来，变红，然后算距离

  1 #include <bits/stdc++.h>
  2 using namespace std;
  3 
  4 #define N 100010
  5 #define ll long long
  6 #define INFLL 0x3f3f3f3f3f3f3f3f
  7 
  8 struct Edge
  9 {
 10     int to, nx; ll w;
 11     inline Edge() {}
 12     inline Edge(int to, int nx, ll w) : to(to), nx(nx), w(w) {}
 13 }edge[N << 1];
 14 
 15 int t, n, m, q, k;
 16 int isred[N], prered[N], head[N], arr[N], pos;
 17 int rmq[N << 1], F[N << 1], P[N], deep[N], cnt; 
 18 ll dist[N]; 
 19 
 20 inline void Init()
 21 {
 22     memset(head, -1, sizeof head); pos = 0;
 23     memset(isred, 0, sizeof isred);  deep[1] = 0;
 24 }
 25 
 26 inline void addedge(int u, int v, ll w)
 27 {
 28     edge[++pos] = Edge(v, head[u], w); head[u] = pos;
 29 }
 30 
 31 struct ST
 32 {
 33     int mm[N << 1];
 34     int dp[N << 1][20];
 35     inline void init(int n)
 36     {
 37         mm[0] = -1;
 38         for (int i = 1; i <= n; ++i)
 39         {
 40             mm[i] = ((i & (i - 1)) == 0) ? mm[i - 1] + 1 : mm[i - 1];
 41             dp[i][0] = i;
 42         }
 43         for (int j = 1; j <= mm[n]; ++j)
 44         {
 45             for (int i = 1; i + (1 << j) - 1 <= n; ++i)
 46             {
 47                 dp[i][j] = rmq[dp[i][j - 1]] < rmq[dp[i + (1 << (j - 1))][j - 1]] ? dp[i][j - 1] : dp[i + (1 << (j - 1))][j - 1];
 48             }
 49         }
 50     }
 51     inline int query(int a, int b)
 52     {
 53         if (a > b) swap(a, b);
 54         int k = mm[b - a + 1];
 55         return rmq[dp[a][k]] <= rmq[dp[b - (1 << k) + 1][k]] ? dp[a][k] : dp[b - (1 << k) + 1][k];
 56     }
 57 }st;
 58 
 59 inline void DFS(int u, int pre, int prer)
 60 {
 61     F[++cnt] = u;
 62     rmq[cnt] = deep[u];
 63     P[u] = cnt;
 64     prered[u] = prer;  
 65     for (int it = head[u]; ~it; it = edge[it].nx)
 66     {
 67         int v = edge[it].to;
 68         if (v == pre) continue;
 69         if (isred[v]) dist[v] = 0;
 70         else dist[v] = dist[u] + edge[it].w;
 71         deep[v] = deep[u] + 1;
 72         DFS(v, u, isred[v] ? v : prer);
 73         F[++cnt] = u;
 74         rmq[cnt] = deep[u];
 75     }
 76 }
 77 
 78 inline void Lca_Init(int root, int node_num)
 79 {
 80     cnt = 0;
 81     DFS(root, root, 1);
 82     st.init(2 * node_num - 1);
 83 }
 84 
 85 inline int query_lca(int u, int v)
 86 {
 87     return F[st.query(P[u], P[v])];
 88 }
 89 
 90 vector <int> v; 
 91 inline bool check(ll mid)
 92 {
 93     v.clear();
 94     for (int i = 1; i <= k; ++i)
 95     {
 96         if (dist[arr[i]] > mid)
 97             v.emplace_back(arr[i]);
 98     }
 99     if (v.empty()) return true; 
100     int lca = v[0];
101     for (int i = 1, len = v.size(); i < len; ++i)
102         lca = query_lca(lca, v[i]);
103     if (isred[lca]) return false;  
104     for (auto it : v)
105     {
106         if (deep[lca] < deep[prered[it]]) return false; 
107         else if (dist[it] - dist[lca] > mid) return false;  
108     }
109     return true;
110 }
111 
112 inline void Run() 
113 {
114     for (scanf("%d", &t); t--; )
115     {
116         scanf("%d%d%d", &n, &m, &q); Init();
117         for (int i = 1, u; i <= m; ++i)
118         {
119             scanf("%d", &u);
120             isred[u] = 1;
121         }
122         ll w;
123         for (int i = 1, u, v; i < n; ++i)
124         {
125             scanf("%d%d%lld", &u, &v, &w);
126             addedge(u, v, w); addedge(v, u, w);
127         }
128         Lca_Init(1, n);
129         for (int qq = 1; qq <= q; ++qq)
130         {
131             scanf("%d", &k);
132             for (int i = 1; i <= k; ++i) scanf("%d", arr + i); 
133             if (k == 1)
134             {
135                 puts("0");
136                 continue;
137             }
138             ll l = 0, r = INFLL, ans; 
139             while (r - l >= 0)
140             {
141                 ll mid = (l + r) >> 1;
142                 if (check(mid))
143                 {
144                     ans = mid;
145                     r = mid - 1;
146                 }
147                 else
148                     l = mid + 1;
149             }
150             printf("%lld\n", ans);
151         }
152     }
153 }
154 
155 int main()
156 {
157     #ifdef LOCAL  
158         freopen("Test.in", "r", stdin); 
159     #endif    
160         
161     Run();
162     return 0;
163 }
View Code

 愚蠢的倍增求LCA（排序一下）

  1 #include<bits/stdc++.h>
  2 
  3 using namespace std;
  4 
  5 typedef long long ll;
  6 
  7 const int INF = 0x3f3f3f3f;
  8 const ll INFLL = 0x3f3f3f3f3f3f3f3f;
  9 const ll MOD = (int)1e9 + 7;
 10 const int maxn = (int)1e5 + 10;
 11 
 12 const int DEG = 20;
 13 
 14 struct Edge {
 15     int to, nxt;
 16     ll w;
 17     inline Edge(){}
 18     inline Edge(int to,int nxt,ll w):to(to),nxt(nxt),w(w){}
 19 }edge[maxn << 1];
 20 
 21 int head[maxn], tot;
 22 int red[maxn];
 23 
 24 inline void addedge(int u, int v, ll w)
 25 {
 26     edge[tot] = Edge(v, head[u], w); head[u] = tot++;
 27 }
 28 
 29 inline void Init(int n)
 30 {
 31     for (int i = 1; i <= n; ++i)
 32     {
 33         red[i] = 0;
 34         head[i] = -1;
 35     }
 36     tot = 0;
 37 }
 38 
 39 ll dis[maxn];
 40 int fa[maxn][DEG];
 41 int deg[maxn];
 42 int pre[maxn];
 43 
 44 inline void BFS(int root)
 45 {
 46     queue<int>q;
 47     dis[root] = 0;
 48     deg[root] = 0;
 49     fa[root][0] = root;
 50     pre[root] = root;
 51     q.push(root);
 52     while (!q.empty())
 53     {
 54         int tmp = q.front();
 55         q.pop();
 56         for (int i = 1; i < DEG; ++i)
 57         {
 58             fa[tmp][i] = fa[fa[tmp][i - 1]][i - 1];
 59         }
 60         for (int i = head[tmp]; ~i; i = edge[i].nxt)
 61         {
 62             int v = edge[i].to;
 63             ll w = edge[i].w;
 64             if (v == fa[tmp][0]) continue;
 65             deg[v] = deg[tmp] + 1;
 66             fa[v][0] = tmp;
 67             if (red[v])
 68             {
 69                 pre[v] = v;
 70             }
 71             else
 72             {
 73                 pre[v] = pre[tmp];
 74             }
 75             if (red[v])
 76             {
 77                 dis[v] = 0;
 78             }
 79             else
 80             {
 81                 dis[v] = dis[tmp] + w;
 82             }
 83             q.push(v);
 84         }
 85     }
 86 }
 87 
 88 inline int LCA(int u, int v)
 89 {
 90     if (deg[u] > deg[v]) swap(u, v);
 91     int hu = deg[u], hv = deg[v];
 92     int tu = u, tv = v;
 93     for (int det = hv - hu, i = 0; det; det >>= 1, ++i)
 94     {
 95         if (det & 1)
 96         {
 97             tv = fa[tv][i];
 98         }
 99     }
100     if (tu == tv) return tu;
101     for (int i = DEG - 1; i >= 0; --i)
102     {
103         if (fa[tu][i] == fa[tv][i]) continue;
104         tu = fa[tu][i], tv = fa[tv][i];
105     }
106     return fa[tu][0];
107 }
108 
109 int n, m, q, k;
110 int arr[maxn];
111 
112 inline bool cmp(int a, int b)
113 {
114     return dis[a] > dis[b];
115 }
116 
117 inline bool check(ll mid)
118 {
119     int root = arr[1];
120     int cnt = 0;
121     for (int i = 1; i <= k; ++i)
122     {
123         if (dis[arr[i]] > mid)
124         {
125             if (pre[root] != pre[arr[i]]) return false;
126             root = LCA(root, arr[i]);
127             cnt++;
128         }
129     }
130     if (cnt == 1 || cnt == 0) return true;
131     for (int i = 1; i <= k; ++i)
132     {
133         if (dis[arr[i]] > mid)
134         {
135             if (dis[arr[i]] - dis[root] > mid) return false;
136         }
137     }
138     return true;
139 }
140 
141 inline void RUN()
142 {
143     int t;
144     scanf("%d", &t);
145     while (t--)
146     {
147         scanf("%d %d %d", &n, &m, &q);
148         Init(n);
149         for (int i = 1; i <= m; ++i)
150         {
151             int u;
152             scanf("%d", &u);
153             red[u] = 1;
154         }
155         for (int i = 1; i < n; ++i)
156         {
157             int u, v;
158             ll w;
159             scanf("%d %d %lld", &u, &v, &w);
160             addedge(u, v, w);
161             addedge(v, u, w);
162         }
163         BFS(1);
164         while (q--)
165         {
166             scanf("%d", &k);
167             for (int i = 1; i <= k; ++i)
168             {
169                 scanf("%d", arr + i);
170             }
171             if (k == 1)
172             {
173                 puts("0");
174                 continue;
175             }
176             sort(arr + 1, arr + 1 + k, cmp);
177             ll l = 0;
178             ll r = INFLL;
179             ll ans = 0;
180             while (r - l >= 0)
181             {
182                 ll mid = (r + l) >> 1;
183                 if (check(mid))
184                 {
185                     r = mid - 1;
186                     ans = mid;
187                 }
188                 else
189                 {
190                     l = mid + 1;
191                 }
192             }
193             printf("%lld\n", ans);
194         }
195     }
196 }
197 
198 int main()
199 {
200 #ifdef LOCAL_JUDGE
201     freopen("Text.txt", "r", stdin);
202 #endif // LOCAL_JUDGE
203 
204     RUN();
205 
206 #ifdef LOCAL_JUDGE
207     fclose(stdin);
208 #endif // LOCAL_JUDGE
209     return 0;
210 }
View Code

 

 

 

C Halting Problem

题意：给出五种操作，机器从第一条命令开始，问是否能到n+1条命令。

思路：暴力，记录状态，若来到重复状态则输出No

  1 #include<bits/stdc++.h>
  2 
  3 using namespace std;
  4 
  5 typedef long long ll;
  6 const double eps = 1e-8;
  7 const int INF = 0x3f3f3f3f;
  8 const ll MOD = (int)1e9 + 7;
  9 const int maxn = (int)1e4 + 10;
 10 
 11 int n, num;
 12 int vis[maxn][260];
 13 struct node {
 14     char op[10];
 15     int v, k;
 16 }arr[maxn];
 17 
 18 inline void RUN()
 19 {
 20     int t;
 21     scanf("%d", &t);
 22     while (t--)
 23     {
 24         scanf("%d", &n);
 25         for (int i = 1; i <= n; ++i)
 26         {
 27             for (int j = 0; j < 256; ++j)
 28             {
 29                 vis[i][j] = 0;
 30             }
 31         }
 32         int flag = true;
 33         int s = 0;
 34         int now = 1;
 35         for (int i = 1; i <= n; ++i)
 36         {
 37             scanf("%s", arr[i].op);
 38             if (strcmp(arr[i].op,"add") == 0)
 39             {
 40                 scanf("%d", &arr[i].v);
 41                 arr[i].k = 0;
 42             }
 43             else
 44             {
 45                 scanf("%d %d", &arr[i].v, &arr[i].k);
 46             }
 47         }
 48         while (1)
 49         {
 50             if (now == n + 1)
 51             {
 52                 flag = true;
 53                 break;
 54             }
 55             if (vis[now][s])
 56             {
 57                 flag = false;
 58                 break;
 59             }
 60             vis[now][s]++;
 61             if (strcmp(arr[now].op, "add") == 0)
 62             {
 63                 s = (s + arr[now].v);
 64                 if (s >= 256)s -= 256;
 65                 now++;
 66             }
 67             else if (strcmp(arr[now].op, "beq") == 0)
 68             {
 69                 if (s == arr[now].v)
 70                 {
 71                     now = arr[now].k;
 72                 }
 73                 else
 74                 {
 75                     now++;
 76                 }
 77             }
 78             else if (strcmp(arr[now].op, "bne") == 0)
 79             {
 80                 if (s != arr[now].v)
 81                 {
 82                     now = arr[now].k;
 83                 }
 84                 else
 85                 {
 86                     now++;
 87                 }
 88             }
 89             else if (strcmp(arr[now].op, "blt") == 0)
 90             {
 91                 if (s < arr[now].v)
 92                 {
 93                     now = arr[now].k;
 94                 }
 95                 else
 96                 {
 97                     now++;
 98                 }
 99             }
100             else if (strcmp(arr[now].op, "bgt") == 0)
101             {
102                 if (s > arr[now].v)
103                 {
104                     now = arr[now].k;
105                 }
106                 else
107                 {
108                     now++;
109                 }
110             }
111         }
112         puts(flag ? "Yes" : "No");
113     }
114 }
115 
116 int main()
117 {
118 #ifdef LOCAL_JUDGE
119     freopen("Text.txt", "r", stdin);
120 #endif // LOCAL_JUDGE
121 
122     RUN();
123 
124 #ifdef LOCAL_JUDGE
125     fclose(stdin);
126 #endif // LOCAL_JUDGE
127     return 0;
128 }
View Code

 

 

D Pixel Art

留坑。

 

E Infinite Parenthesis Sequence

留坑。

 

F Chaleur

留坑。

 

G Couleur

题意：每次标记一个数不可用，那么就将原数组分成多一段，然后找出子数组中异或最大。

思路：每次划分成两边，对小的那边暴力，可以用set 来找左界右界，map 来找出当前界中的值  multiset 找最大值

  1 #include <bits/stdc++.h>
  2 using namespace std; 
  3 
  4 #define N 100010
  5 #define M N * 30  
  6 using ll = long long; 
  7 using pii = pair <int, int>; 
  8 
  9 int t, n;
 10 set <int> s; 
 11 multiset <ll> mst; 
 12 map <pii, ll> mp; 
 13 int arr[N], p[N];  
 14 ll ans;
 15 
 16 struct BIT 
 17 {
 18     int a[N];  
 19     inline void update(int x)
 20     {  
 21         for (int i = x; i <= n; i += i & -i)
 22             ++a[i];
 23     }  
 24     inline int query(int x)
 25     { 
 26         int res = 0;
 27         for (int i = x; i > 0; i -= i & -i)
 28             res += a[i];
 29         return res;
 30     }  
 31 }bit; 
 32 
 33 struct chairman_tree
 34 {
 35     int T[N], L[M], R[M], C[M], tot;
 36     inline int build(int l, int r)
 37     {
 38         int root = tot++;
 39         C[root] = 0;
 40         if (l < r)
 41         {
 42             int mid = (l + r) >> 1; 
 43             L[root] = build(l, mid);
 44             R[root] = build(mid + 1, r);
 45         }
 46         return root;
 47     }
 48     inline int update(int root, int pos)
 49     {
 50         int newroot = tot++, tmp = newroot;
 51         C[newroot] = C[root] + 1;
 52         int l = 1, r = n;
 53         while (l < r)
 54         {
 55             int mid = (l + r) >> 1;
 56             if (pos <= mid)
 57             {
 58                 L[newroot] = tot++; R[newroot] = R[root];
 59                 newroot = L[newroot], root = L[root];
 60                 r = mid;
 61             }
 62             else
 63             {
 64                 L[newroot] = L[root], R[newroot] = tot++;
 65                 newroot = R[newroot], root = R[root];
 66                 l = mid + 1; 
 67             }
 68             C[newroot] = C[root] + 1; 
 69         }
 70         return tmp;
 71     }
 72     inline int query(int left_root, int right_root, int pos, int vis)
 73     {
 74         int l = 1, r = n, res = 0;
 75         while (l < r)
 76         {
 77             int mid = (l + r) >> 1;
 78             if (pos <= mid)
 79             {
 80                 left_root = L[left_root];
 81                 right_root = L[right_root];
 82                 r = mid;
 83             }
 84             else
 85             {
 86                 res += C[L[left_root]] - C[L[right_root]];
 87                 left_root = R[left_root];
 88                 right_root = R[right_root];
 89                 l = mid + 1;
 90             }
 91         }
 92         if (vis) res += C[left_root] - C[right_root];
 93         return res;   
 94     }
 95 }ct; 
 96 
 97 inline void Init()
 98 {
 99     memset(bit.a, 0, sizeof bit.a); ct.tot = 0;
100     s.clear(), mst.clear(), mp.clear(); ans = 0;
101     s.emplace(0), s.emplace(n + 1);
102     ct.T[n + 1] = ct.build(1, n); 
103 }
104 
105 inline void Run()
106 {
107     for (scanf("%d", &t); t--; )
108     {
109         scanf("%d", &n); Init();
110         for (int i = 1; i <= n; ++i)
111         {
112             scanf("%d", arr + i);
113             bit.update(arr[i]);
114             ans += i - bit.query(arr[i]);
115         }
116         for (int i = 1; i <= n; ++i) scanf("%d", p + i);
117         for (int i = n; i >= 1; --i) ct.T[i] = ct.update(ct.T[i + 1], arr[i]);
118         mp[pii(1, n)] = ans; mst.insert(ans);
119         for (int i = 1; i <= n; ++i)
120         {
121             printf("%lld%c", ans, " \n"[i == n]);
122             if (ans)
123             {
124                 int id = int(ans ^ p[i]), l, r;
125                 l = *(--s.upper_bound(id)) + 1; 
126                 r = *(s.upper_bound(id)) - 1; s.insert(id);
127                 ll val = mp[pii(l, r)];
128                 mst.erase(mst.lower_bound(val));  
129                 mp.erase(pii(l, r)); 
130                 val -= id - l - ct.query(ct.T[l], ct.T[id], arr[id], 1);
131                 if (id - l < r - id) // goto left   
132                 {
133                     for (int j = l; j <= id; ++j)
134                         val -= ct.query(ct.T[id + 1], ct.T[r + 1], arr[j], 0);
135                     ll vall = 0, valr = 0;
136                     for (int j = l + 1; j < id; ++j)
137                         vall += j - l - ct.query(ct.T[l], ct.T[j], arr[j], 1);
138                     valr = val - vall;
139                     mst.insert(vall), mst.insert(valr);
140                     mp[pii(l, id - 1)] = vall; mp[pii(id + 1, r)] = valr;
141                 }
142                 else   // goto right                     
143                 {
144                     for (int j = id + 1; j <= r; ++j)
145                         val -= id - l + 1 - ct.query(ct.T[l], ct.T[id + 1], arr[j], 1);
146                     ll vall = 0, valr = 0; 
147                     for (int j = id + 1; j <= r; ++j)
148                         valr += j - id - 1 - ct.query(ct.T[id + 1], ct.T[j], arr[j], 1);
149                     vall = val - valr;
150                     mst.insert(vall), mst.insert(valr);
151                     mp[pii(l, id - 1)] = vall; mp[pii(id + 1, r)] = valr;
152                 }
153                 ans = *(mst.rbegin());
154             }
155         }
156     }
157 }
158 
159 int main()
160 {
161     #ifdef LOCAL  
162         freopen("Test.in", "r", stdin);
163     #endif    
164 
165     Run();
166     return 0;
167 }
View Code

 

 

H Traveling on the Axis

题意：一个字符串表示当前点是红灯还是绿灯，灯一秒变一次，求$\sum_{p = 0}^{n - 1}\sum_{q = p +1}^{n} t(p, q)$

思路：前缀搞一搞

 1 #include<bits/stdc++.h>
 2 
 3 using namespace std;
 4 
 5 char st[100000+10];
 6 long long f[100000+10];
 7 int main() {
 8     long long t,n,i,j,k;
 9     long long ans;
10     scanf("%lld",&t);
11     while (t--) {
12         scanf("%s",st);
13         n=strlen(st);
14         f[1]=1; ans=0;
15         for (i=1;i<n;++i) 
16             if (st[i]==st[i-1]) f[i+1]=2;
17             else f[i+1]=1;
18         for (i=1;i<=n;++i) {
19             ans+=(f[i])*i*(n-i+1);
20             if (st[i-1]=='0') ans+=n-i+1;
21             if (f[i]==2) ans-=n-i+1;
22         }
23         printf("%lld\n",ans);
24     }
25     return 0;
26 }
View Code

 

J Press the Button

题意：周期性按灯，每按一次，如果灯本来是亮着就++， 求最后+了多少次

思路：记录lcm时间内的增加次数以及t%lcm时间内的增加次数。用两个时间节点记录两人下次按的时间，然后暴力跑出lcm以及t%lcm时间内的增加次数即可

  1 #include<bits/stdc++.h>
  2 
  3 using namespace std;
  4 
  5 typedef long long ll;
  6 const double eps = 1e-8;
  7 const int INF = 0x3f3f3f3f;
  8 const ll MOD = (int)1e9 + 7;
  9 const int maxn = (int)1e4 + 10;
 10 
 11 inline ll gcd(ll a, ll b)
 12 {
 13     return b == 0 ? a : gcd(b, a%b);
 14 }
 15 
 16 ll a, b, c, d, v, t;
 17 
 18 inline void RUN()
 19 {
 20     int cas;
 21     scanf("%d", &cas);
 22     while (cas--)
 23     {
 24         scanf("%lld %lld %lld %lld %lld %lld", &a, &b, &c, &d, &v, &t);
 25         ll G = gcd(a, c);
 26         G = a * c / G;
 27         //cout << G << endl;
 28         ll res =0;
 29         ll res1 =  b - 1 + d;
 30         ll len = t / G;
 31         ll M = t % G;
 32         ll t1 = a;
 33         ll t2 = c;
 34         ll now = 0;
 35         while (t1 <= G && t2 <= G)
 36         {
 37             if (t1 < t2)
 38             {
 39                 ll tmp = t1 - now;
 40                 if (tmp > v)
 41                 {
 42                     res += b - 1;
 43                     if (t1 <= M)
 44                     {
 45                         res1 += b - 1;
 46                     }
 47                 }
 48                 else
 49                 {
 50                     res += b;
 51                     if (t1 <= M)
 52                     {
 53                         res1 += b;
 54                     }
 55                 }
 56                 now = t1;
 57                 t1 += a;
 58 
 59             }
 60             else if (t1 > t2)
 61             {
 62                 ll tmp = t2 - now;
 63                 if (tmp > v)
 64                 {
 65                     res += d - 1;
 66                     if (t2 <= M)
 67                     {
 68                         res1 += d - 1;
 69                     }
 70                 }
 71                 else
 72                 {
 73                     res += d;
 74                     if (t2 <= M)
 75                     {
 76                         res1 += d;
 77                     }
 78                 }
 79                 now = t2;
 80                 t2 += c;
 81             }
 82             else if (t1 == t2)
 83             {
 84                 ll tmp = t1 - now;
 85                 if (tmp > v)
 86                 {
 87                     res += b + d - 1;
 88                     if (t1 <= M)
 89                     {
 90                         res1 += b + d - 1;
 91                     }
 92                 }
 93                 else
 94                 {
 95                     res += b + d;
 96                     if (t1 <= M)
 97                     {
 98                         res1 += b + d;
 99                     }
100                 }
101                 now = t1;
102                 t1 += a;
103                 t2 += c;
104 
105             }
106         }
107         ll ans = res * len + res1;
108         printf("%lld\n", ans);
109     }
110 }
111 
112 int main()
113 {
114 #ifdef LOCAL_JUDGE
115     freopen("Text.txt", "r", stdin);
116 #endif // LOCAL_JUDGE
117 
118     RUN();
119 
120 #ifdef LOCAL_JUDGE
121     fclose(stdin);
122 #endif // LOCAL_JUDGE
123     return 0;
124 }
View Code

 

K XOR Clique

题意：给出n个数，求选出一个点集，使得里面的点两两异或不超过这两个数中小的那个，求点集里面元素个数最大是多少

思路：枚举最高位

 1 #include<bits/stdc++.h>
 2 
 3 using namespace std;
 4 
 5 typedef long long ll;
 6 const double eps = 1e-8;
 7 const int INF = 0x3f3f3f3f;
 8 const ll MOD = (int)1e9 + 7;
 9 const int maxn = (int)1e6 + 10;
10 
11 int n, num;
12 int arr[40];
13 
14 inline void RUN()
15 {
16     int t;
17     scanf("%d", &t);
18     while (t--)
19     {
20         int ans = 0;
21         scanf("%d", &n);
22         memset(arr, 0, sizeof arr);
23         for (int i = 1; i <= n; ++i)
24         {
25             scanf("%d", &num);
26             int cnt = 0;
27             while (num)
28             {
29                 cnt++;
30                 num >>= 1;
31             }
32             arr[cnt]++;
33             ans = max(ans, arr[cnt]);
34         }
35         printf("%d\n", ans);
36     }
37 }
38 
39 int main()
40 {
41 #ifdef LOCAL_JUDGE
42     freopen("Text.txt", "r", stdin);
43 #endif // LOCAL_JUDGE
44 
45     RUN();
46 
47 #ifdef LOCAL_JUDGE
48     fclose(stdin);
49 #endif // LOCAL_JUDGE
50     return 0;
51 }
View Code

 

转载于:https://www.cnblogs.com/Dup4/p/9657033.html

banshen0201
关注
The 2018 ACM-ICPC Asia Qingdao Regional Contest（部分题解）
aisebu7819的博客
11-13 574
摘要： 　　本文是The 2018 ACM-ICPC Asia Qingdao Regional Contest（青岛现场赛）的部分解题报告，给出了出题率较高的几道题的题解，希望熟悉区域赛的题型，进而对其他区域赛的准备有借鉴意义。 Function and Function 题意 给出x和k，计算gk(x)。 解题思路 通过观察发现，g函数经过一定次数的递推一定会在...
2017-2018 ACM-ICPC Southeastern European Regional Programming Contest (SEERC 2017)
wang_viscaria的博客
10-23 563
Rank Solved A B C D E F G H I J K L ?/? 7/12 O . . O . O O . . O O O O: 当场通过 Ø: 赛后通过 .: 尚未通过 A Concerts solved by chelly chelly’s solution B Bricks unsolved C Christmas Tree unsolved D Ha...
The 2018 ACM-ICPC Asia Qingdao Regional Contest, Online 青岛，C Halting Problem 模拟 + 卡常
GreyBtfly的博客
09-16 858
博客目录 原题 传送门 作者: 浙江大学竞赛命题组 单位: ACMICPC 时间限制: 500 ms 内存限制: 64 MB 代码长度限制: 32 KB In computability theory, the halting problem is the problem of determining, from a description of an arbitrary comp...
The 2018 ACM-ICPC Asia Qingdao Regional Contest
weixin_30492601的博客
11-06 157
恭喜我校某兰区域赛第一次获奖！ 队友666，老师666！ 4070 Function and Function 比赛时写得比较复杂了，比赛后得出循环只有0,1两个。那时候心态小崩。 1 #include <cstdio> 2 #include <cstdlib> 3 #include <cmath> 4 #inclu...
The 2018 ACM-ICPC Asia Qingdao Regional Contest, Online
LMengi000的博客
09-19 537
    ID Title Source 4047 Live Love The 2018 ACM-ICPC Asia Qingdao Regional Contest, Online 4048 Red Black Tree The 2018 ACM-ICPC Asia Qingdao Region...
The 2018 ACM-ICPC Asia Qingdao Regional Contest（青岛网络赛）
weixin_30887919的博客
09-16 229
ALive Love 水 #include <algorithm> #include<cstdio> #include<cstring> using namespace std; typedef long long ll; const int inf = 0x3f3f3f3f; const int maxn = 1e5 + 1; ...
2015-2016 ACM-ICPC Northeastern European Regional Contest 标程
08-23
【标题】"2015-2016 ACM-ICPC Northeastern European Regional Contest 标程" 提供的是一个编程竞赛的参考资料，这是一场由ACM（Association for Computing Machinery）主办的国际大学生程序设计竞赛（International...
个人ACM-ICPC模板acm-icpc-master.zip
最新发布
02-05
标题中的“个人ACM-ICPC模板acm-icpc-master.zip”指的是一个与ACM国际大学生程序设计竞赛（International Collegiate Programming Contest, ICPC）相关的个人开发的模板项目。这个压缩包很可能是参赛者或者教练为了...
2018-2019 ACM-ICPC, Asia Jiaozuo Regional Contest
lingdie_yy的博客
12-11 266
2018-2019 ACM-ICPC, Asia Jiaozuo Regional Contest https://codeforces.com/gym/102028 2020-12-11 --时间 A. 签到 const int maxn = 1e5 + 7; int t, n; char s[10][1000] = {"Typically Otaku", "Eye-opener", "Young Traveller", "Exc..
The 2018 ACM-ICPC Asia Qingdao Regional Contest J Press the Button
CaprYang的博客
09-16 1013
题解 题目大意 两个人A和B A每a秒按开关b次 B每c秒按开关d次 灯泡亮v秒 总共时长t 问在t秒结束时计数器的值是多少 灯泡灭的时候按开关则会亮v+0.5秒 亮的时候按开关则计数器+1并且刷新亮时间到v+0.5秒 开场0秒的时候A和B都会去按开关 a和b的范围最大1e6 以a和b最小公倍数为一个周期 计算量不会超过1e6 计算每个周期计数器增加的量 乘上周期个数 加上不满一个周期的...
The 2018 ACM-ICPC Asia Qingdao Regional Contest, Online A,K,C
sjs_caomei的博客
09-16 298
K XOR Clique BaoBao has a sequence a​1​​,a​2​​,...,a​n​​. He would like to find a subset S of {1,2,...,n} such that ∀i,j∈S, a​i​​⊕a​j​​&lt;min(a​i​​,a​j​​) and ∣S∣ is maximum, where ⊕ means bitwise e...
The 2018 ACM-ICPC Asia Qingdao Regional Contest (Mirror) - J Books（贪心）
zamaochick的博客
11-11 304
 这个题想了好久也没想出来，转不过弯来啊。 思路： 先讨论Impossible的情况，如果书的价格为0的个数大于所要买的书本的数量，则为Impossible的情况。 然后是Richman的情况，如果n==m则为Richman的情况。 接下来是一般的情况，先将0项去除，然后累加前m减去0项的数目，然后加上后面序列的最小值-1. 代码如下：   #include &lt;cstd...
CodeForces 675 A Infinite Sequence
Calm微笑
05-26 389
F - Infinite Sequence Time Limit:1000MS     Memory Limit:262144KB     64bit IO Format:%I64d & %I64u Submit Status Description Vasya likes everything infinite. Now he is studying the pr
[arc071f]Infinite Sequence
不来也不去的一只失忆蝴蝶
11-04 585
前言怎么这题1000分啊。题目大意一个无穷序列，要求所有大于n的项都和第n项相同。 如果一个位置值为k，接下来k个位置必须相同。 每个位置填1~n的数，求方案数。做法显然相邻两个位置>1后面就全tm一样了。 然后就很tm好做。#include<cstdio> #include<algorithm> #define fo(i,a,b) for(i=a;i<=b;i++) using namesp
C. Serval and Parenthesis Sequence（合法括号序列）
cherish_lin的博客
04-22 725
Serval soon said goodbye to Japari kindergarten, and began his life in Japari Primary School. In his favorite math class, the teacher taught him the following interesting definitions. Aparenthesis ...
ACM-ICPC 2018 焦作赛区网络预赛 I. Save the Room
weixin_30788619的博客
09-15 176
Bob is a sorcerer. He lives in a cuboid room which has a length ofAA, a width ofBBand a height ofCC, so we represent it asAA*BB*CC. One day, he finds that his room is f...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值