codeforces#518 Div2 ABCDE

A---Birthday

http://codeforces.com/contest/1068/problem/A

题意：

有n种硬币，m个人。m个人要给Ivan送硬币，每个人送的硬币都要互不相同但数量一样。Ivan现在已经有k种了，具体哪k种不知道。现在要求朋友们送的硬币至少有l种是IVan没有的。

思路：

刚开始想的是l/m取上整。后来发现题意是不知道Ivan有的是哪几种，为了保证一定至少l种的话，就需要（l+k）/m取上整。

不可能的情况是人数乘每个人送的硬币数超过n。

用longlong

 #include <bits/stdc++.h>
 #define inf 0x3f3f3f3f
 using namespace std;

 long long n, m, l, k;
 int main()
 {
     while(scanf("%I64d%I64d%I64d%I64d", &n, &m, &k, &l) != EOF){
         long long cnt;
         if((l + k) % m == ){
             cnt = (l + k) / m;
         }
         else {
             cnt = (l + k) / m + ;
         }
         if(cnt * m > n){
             printf("-1\n");
         }
         else{
             printf("%I64d\n", cnt);

         }

     }
     return ;
 }

B---LCM

http://codeforces.com/contest/1068/problem/B

题意：

给定一个数b，问对于1~1e18的所有数a，\(\frac{lcm(a,b)}{a}\)有多少种可能。

思路：

\(\frac{lcm(a,b)}{a} = \frac{a*b}{a*gcd(a,b)} = \frac{b}{gcd(a,b)}\)

所以只需要统计b的因子数就行了，a是1~1e18，因子肯定是多于b的。

 #include <bits/stdc++.h>
 #define inf 0x3f3f3f3f
 using namespace std;
 typedef long long LL;

 LL b;

 int main()
 {
     while(scanf("%I64d", &b) != EOF){
         int cnt = ;
         for(int i = ; i <= sqrt(b); i++){
             if(b % i == ){
                 if(i != sqrt(b)){
                     cnt += ;
                 }
                 else{
                     cnt++;
                 }
             }
         }
         printf("%d\n", cnt);
     }
     return ;
 }

C---Colored Rooks【思维好题】

http://codeforces.com/contest/1068/problem/C

题意：

有n种颜色，给定m对关系。每对关系有一个颜色a和颜色b，表示a和b时候harmonize。现在要把n种颜色放进一个1e9*1e9的棋盘中，同一个颜色的子集要相连通，不同的不能相连，harmonize的颜色也要相连通。问如何摆放。

思路：

看上去就应该是以某一种策略进行摆放就可以了。但是我居然刚开始愚蠢的在想dfs。后来想想这也 太复杂了吧。

首先我们应该能想到同一个颜色的子集肯定都是能相连的。

那就只用考虑让不同的别相连就行了。这也的话，每个颜色i都放在（i，i）中，就好了。

最后要考虑怎样让harmonize的颜色相连。因为棋盘很大啊，而且也没有说放的数量要尽量少，所以在新的空行 j 里（j,a）放a (j,b）放 b 就可以了。这也不会影响前面。

 #include <bits/stdc++.h>
 #define inf 0x3f3f3f3f
 using namespace std;
 typedef long long LL;

 int n, m;
 struct node{
     int x, y;
     node(){}
     node(int i, int j){
         x = i;
         y = j;
     }
 };
 vector<node>grid[];

 int main()
 {
     while(scanf("%d%d", &n, &m) != EOF){
         for(int i = ; i <= n; i++){
             grid[i].clear();
             grid[i].push_back(node(i, i));
         }
         int j = n + ;
         for(int i = ; i < m; i++){
             int a, b;
             scanf("%d%d", &a, &b);
             grid[a].push_back(node(a, j));
             grid[b].push_back(node(b, j));
             j++;
         }

         for(int i = ; i <= n; i++){
             printf("%d\n", grid[i].size());
             for(int j = ; j < grid[i].size(); j++){
                 printf("%d %d\n", grid[i][j].x, grid[i][j].y);
             }
         }
     }
     return ;
 }

D---Array Without Local Maximum

http://codeforces.com/contest/1068/problem/D

题意：

给定一个序列，序列中数的范围在1~200， -1的地方表示不知道这个位置的数是多少。现在要求最后的序列中没有局部最大值，问有多少种填数的方案。

思路：

最开始就想到应该是dp，用\(dp[i][j]\)表示第\(i\)个位置填的是\(j\)时的方案数。

刚开始天真的觉得最后的序列要么非递减要么非递增。实际上并不是的。由于存在相等的情况，序列不一定是单调的。

但是可以知道仍然存在着两种情况：1.\(i-1\)的数比\(i\)的要小  2.\(i-1\)的数要大于等于\(i\)的

因此dp数组要再多开一维，\(dp[i][j][0]\)表示第\(i\)个位置填\(j\)且前一个数比他小，\(dp[i][j][1]\)表示第\(i\)个位置填\(j\)且前一个数大于等于他

于是我们可以得到状态转移方程：

\(dp[i][j][0] = sum_{k = 1} ^ {j}(dp[i-1][k][0] + dp[i-1][k][1])\)

\(dp[i][j][1] = sum_{k = j} ^ {200}dp[i-1][k][1] + dp[i - 1][j][0]\) 当\(num[i-1]\)大于等于\(num[i]\)时，\(num[i-2]\)只能大于等于\(num[i-1]\)

对于\(num[i] != -1\)，我们只转移\(dp[i][num[i]][0]\)和\(dp[i][num[i]][1]\)

而且我们发现转移方程中有一部分求和，j增大，他们对应也变多。所以用前缀和维护一下。

要使用longlong。而且对于\( - \)，要先\( +mod \) 再 \( %mod \) ，\(sum\)数组因为对于\(i \)只会用到 \(i-1\)的求和，所以不需要开三维，否则会MLE

最后的输出应该是\(dp[n][num[n][1]\)或\(sum[200][1]\)

 #include <bits/stdc++.h>
 #define inf 0x3f3f3f3f
 using namespace std;
 typedef long long LL;

 int n;
 const int maxn = 1e5 + ;
 const int mod = ;
 int num[maxn];
 LL dp[maxn][][], sum[][];

 int main()
 {
     while(scanf("%d", &n) != EOF){
         for(int i = ; i <= n; i++){
             scanf("%d", &num[i]);
             memset(dp[i], , sizeof(dp[i]));
             //memset(sum[i], 0, sizeof(sum[i]));
         }
         memset(sum, , sizeof(sum));

         if(num[] != -){
             dp[][num[]][] = 1ll;
             for(int j = num[]; j <= ; j++){
                 sum[j][] = 1ll;
             }
         }
         else{
             for(int j = ; j <= ; j++){
                 dp[][j][] = 1ll;
                 sum[j][] = (sum[j - ][] + 1ll) % mod;
             }
         }

         for(int i = ; i <= n; i++){
             if(num[i] != -){
                 dp[i][num[i]][] = (sum[num[i] - ][] + sum[num[i] - ][]) % mod;
                 dp[i][num[i]][] = (dp[i - ][num[i]][] + sum[][]) % mod;
                 dp[i][num[i]][] = (dp[i][num[i]][] - sum[num[i] - ][] + mod) % mod;
                 memset(sum, , sizeof(sum));
                 for(int j = num[i]; j <= ; j++){
                     sum[j][] = dp[i][num[i]][] % mod;
                     sum[j][] = dp[i][num[i]][] % mod;
                 }
             }
             else{
                 for(int j = ; j <= ; j++){
                     dp[i][j][] = (sum[j - ][] + sum[j - ][]) % mod;
                     dp[i][j][] = (dp[i - ][j][] + sum[][]) % mod;
                     dp[i][j][] = (dp[i][j][] - sum[j - ][] + mod) % mod;
                 }
                 memset(sum, , sizeof(sum));
                 for(int j = ; j <= ; j++){
                     sum[j][] = (sum[j - ][] + dp[i][j][]) % mod;
                     sum[j][] = (sum[j - ][] + dp[i][j][]) % mod;
                 }

             }
         }

         if(num[n] != -){
             printf("%lld\n", dp[n][num[n]][] % mod);
         }
         else{
             printf("%lld\n", sum[][] % mod);
         }
     }

     return ;
 }

E---Multihedgehog

http://codeforces.com/contest/1068/problem/E

题意：

1-hedgehog是有一个节点的度至少是3，其他的节点度都是1

k-hedgehog是有一个节点的度至少是3，和他连接的节点都是k-1-hedgehog的中心点

现在给定一棵有n个点的树，问他是不是k-hedgehog

思路：

每次删掉叶子节点，用一个二维数组来存每次删除之后每个节点的度。

删除完之后判断被删除节点的父节点满不满足是p-hedgehog的条件，p是操作的次数。

最后看一下是不是只剩一个节点了。

 #include <bits/stdc++.h>
 #define inf 0x3f3f3f3f
 using namespace std;
 typedef long long LL;

 int n, k;
 const int maxn = 1e5 + ;
 struct edge{
     int v;
     int nxt;
 }e[maxn * ];
 int head[maxn], tot;
 int degree[maxn][], son[maxn];
 bool vis[maxn], yes[maxn];

 void addedge(int u, int v)
 {
     e[tot].v = v;
     e[tot].nxt = head[u];
     head[u] = tot++;
     e[tot].v = u;
     e[tot].nxt = head[v];
     head[v] = tot++;
     degree[u][]++;
     degree[v][]++;
 }

 int main()
 {
     while(scanf("%d%d", &n, &k) != EOF){

         for(int i = ; i <= n; i++){
             head[i] = -;
             memset(degree[i], , sizeof(degree[i]));
             vis[i] = false;
             son[i] = ;
             yes[i] = true;
         }
         tot = ;

         for(int i = ; i < n; i++){
             int u, v;
             scanf("%d%d", &u, &v);
             addedge(u, v);
         }
         if(n <=  || k >= ){
             printf("No\n");
             continue;
         }
         bool flag = true;
         int sum = n;
         for(int p = ; p <= k; p++){
             for(int i = ; i <= n; i++){
                 if(degree[i][p - ] == ){
                     for(int j = head[i]; j != -; j = e[j].nxt){
                         if(vis[e[j].v])continue;
                         if(!vis[e[j].v] && degree[e[j].v][p - ] == ){
                             flag = false;
                             break;
                         }
                         degree[e[j].v][p]++;
                         //if(yes[i])son[e[j].v]++;
                     }
                     vis[i] = true;
                     sum--;
                 }
                 if(!flag)break;
             }
             if(!flag)break;
             for(int i = ; i <= n; i++){
                 if(degree[i][p] ==  || vis[i])continue;
                 if(degree[i][p] <= ){
                     flag = false;
                     break;
                 }
                 degree[i][p] = ;
             }
             if(!flag)break;

             if(sum == ){
                 if(p == k){
                     flag = true;
                     break;
                 }
                 else{
                     flag = false;
                     break;
                 }
             }
         }

         //cout<<cnt<<" "<<flag<<endl;

         if(flag && sum == ){
             printf("Yes\n");
         }
         else{
             printf("No\n");
         }
     }
     return ;
 }