Codeforces Round #375 (Div. 2)

A. The New Year: Meeting Friends

水

 #include <set>
 #include <map>
 #include <stack>
 #include <queue>
 #include <cstdio>
 #include <vector>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 using namespace std;
 typedef long long LL;
 #define mem(x,y) memset(x, y, sizeof(x))
 #define lson l,m,rt << 1
 #define rson m+1,r,rt << 1 | 1
  ? a : gcd(b, a % b);}
 int lcm(int a, int b){return a / gcd(a, b) * b;}
 
 int main()
 {
     ];
     scanf(], &a[], &a[]);
     sort(a, a + );
     printf(] - a[]);
     ;
 }

B - Text Document Analysis

题意：此题是一道字符串题目，统计括号内的单词个数以及括号外最长的单词长度。

字符串的题目漏了考虑'\n'的结尾！！！

 #include <set>
 #include <map>
 #include <stack>
 #include <queue>
 #include <cstdio>
 #include <vector>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 using namespace std;
 typedef long long LL;
 #define mem(x,y) memset(x, y, sizeof(x))
 #define lson l,m,rt << 1
 #define rson m+1,r,rt << 1 | 1
  ? a : gcd(b, a % b);}
 int lcm(int a, int b){return a / gcd(a, b) * b;}
 
 ];
 int main()
 {
     int len;
     scanf("%d", &len);
     scanf("%s", s);
     , len_in = , len_out = , num_in =  ,len_max = ;
     ; i < len; i++)
     {
         if(s[i] == '(')
         {
             flag1 = ;
             len_max = max(len_max, len_out);
             len_out = ;
             continue;
         }
         if(flag1)
         {
             if((s[i] >= 'A' && s[i] <= 'Z') || (s[i] >= 'a' && s[i] <= 'z') )
                 len_in++;
             else if(s[i] == '_')
             {
                 if(len_in) num_in++;
                 len_in = ;
             }
             else if(s[i] == ')')
             {
                 flag1 = ;
                 if(len_in) num_in++;
                 len_in = ;
             }
         }
         else
         {
             if((s[i] >= 'A' && s[i] <= 'Z') || (s[i] >= 'a' && s[i] <= 'z') )
                 len_out++;
             else if(s[i] == '_')
             {
                 len_max = max(len_max, len_out);
                 len_out = ;
             }
         }
     }
     len_max = max(len_max, len_out);
     printf("%d %d\n", len_max, num_in);
     ;
 }

其实写复杂了，hhhhh。别人的

#include<cstdio>
#include <cstring>
#include<cmath>
#include<iostream>
#include<algorithm>
#include<vector>
#include <map>
using namespace std;
 
int main()
{
    ,len=,max=,num=;
    ];
    scanf("%d",&n);
    scanf("%s",ch);
    ;i==||ch[i-]!='\0';i++)
    {
        if(ch[i]=='_'||ch[i]=='('||ch[i]==')'||ch[i]=='\0')
        {
            &&max<len)
            {
                max=len;
            }
            &&len!=)
            {
                num++;
            }
            len=;
            if(ch[i]=='(')
            {
                flag=;
            }
            else if(ch[i]==')')
            {
                flag=;
            }
        }
        else
        {
            len++;
        }
    }
    printf("%d %d",max,num);
    ;
}

C - Polycarp at the Radio

这题意太迷了。读不懂。

D - Lakes in Berland

题意：n*m的图里，‘.’为湖，‘*’为陆地，'.'在边界的是与大海相连（即不为湖），上下左右相连的为同一个湖或者同一片海，现在要求只留下k个湖，问要最少填多少个格子。

直接贪心+dfs就A了。

 #include <set>
 #include <map>
 #include <stack>
 #include <queue>
 #include <cstdio>
 #include <vector>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 using namespace std;
 typedef long long LL;
 #define mem(x,y) memset(x, y, sizeof(x))
 #define lson l,m,rt << 1
 #define rson m+1,r,rt << 1 | 1
  ? a : gcd(b, a % b);}
 int lcm(int a, int b){return a / gcd(a, b) * b;}
 
 int n, m, k, ans, flag;
 ][];
 ][];
 , , , -};
 , -, , };
 #define judge(x, y) 0 <= x && x < n && 0 <= y && y < m && vis[x][y] == 0
 
 struct node
 {
     int x, y, s;
     node(int xx, int yy, int ss){x = xx, y = yy, s = ss;}
     bool operator < (const node& other)const
     {
         return s > other.s;
     }
 };
 int dfs(int x, int y, int id)
 {
     ;
     ;
     vis[x][y] = ;
      || x == n -  || y ==  || y == m - ) flag = ;
      && ma[x][y] == '.')
     {
         ma[x][y] = '*', ans++;
     }
 
     ; i < ; i++)
     {
         int fx = x + dx[i], fy = y + dy[i];
         if(judge(fx, fy) && ma[fx][fy] == '.')
         {
             s += dfs(fx, fy, id);
         }
     }
     return s;
 }
 
 int main()
 {
     scanf("%d%d%d", &n, &m, &k);
     ; i < n; i++)
     {
         scanf("%s", ma[i]);
     }
     priority_queue<node>que;
     ; i < n; i++)
     {
         ; j < m; j++)
         {
              && ma[i][j] == '.')
             {
                 flag = ;
                 );
                 if(t && flag)   que.push(node(i, j, t));
             }
 
         }
     }
     mem(vis, );
     ans = ;
 
     while(que.size() > k)
     {
         node cur = que.top();que.pop();
         dfs(cur.x, cur.y, );
     }
 
     printf("%d\n", ans);
     ; i < n; i++)
         printf("%s\n", ma[i]);
     ;
 }

E. One-Way Reform（欧拉路径）

题意：
给你一个n个点m条边的无向连通图，没有自环没有重边（图论题一定一定要记得考虑有没有自环和重边） ，然后让你给每条边规定方向，希望使得尽可能多的点拥有相同的入度与出度，让你输出满足这个条件的最大点数和每条边最后的定向。

题解：你想吧，一个连通图，如果存在奇数的度数的顶点，那么它的个数一定是偶数个，因为你想啊，连通图吧，度数=边数*2肯定是偶数，对吧。所以奇数度的顶点也一定是偶数个。那么把所有度数为奇数的顶点和一个新增顶点相连，则图上所有顶点的度数就都是偶数了，构成欧拉图，然后欧拉路径。ans数组记录路径。

 #include <set>
 #include <map>
 #include <stack>
 #include <queue>
 #include <cstdio>
 #include <vector>
 #include <cstring>
 #include <iostream>
 #include <algorithm>
 using namespace std;
 typedef long long LL;
 #define mem(x,y) memset(x, y, sizeof(x))
 #define lson l,m,rt << 1
 #define rson m+1,r,rt << 1 | 1
  ? a : gcd(b, a % b);}
 int lcm(int a, int b){return a / gcd(a, b) * b;}
 
 int T, V, E;
  + ;
 set<int>s[maxn_v];
 vector<pair<int, int> >ans;
 void init()
 {
     ; i <= V; i++)
         s[i].clear();
     ans.clear();
 }
 void dfs(int u)
 {
     while(s[u].size())
     {
         int v = *s[u].begin();
         s[u].erase(v);
         s[v].erase(u);
         ans.push_back(make_pair(u, v));
         dfs(v);
     }
 }
 int main()
 {
     scanf("%d", &T);
     while(T--)
     {
         init();
         scanf("%d%d", &V, &E);
         ; i < E; i++)
         {
             int u, v;
             scanf("%d%d", &u, &v);
             s[u].insert(v);
             s[v].insert(u);
         }
         ; i <= V; i++)
         {
             )
             {
                 s[i].insert(V + );
                 s[V + ].insert(i);
             }
         }
         printf(].size());
         ; i <= V; i++)
             dfs(i);
         ; i < ans.size(); i++)
         {
              && ans[i].second != V + )
                 printf("%d %d\n", ans[i].first, ans[i].second);
         }
 
     }
     ;
 }

F. st-Spanning Tree

题意：给你一个n个顶点，m个条边的无向联通图，没有自环没有重边，给你两个顶点，和两个值，让你搞出任意一个生成树，使得两个顶点的度数，分别不超过这两个值。