codeforces#516 Div2---ABCD

A---Make a triangle!

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

题意：

给定三个整数表示三角形的边。每次给边长可以加一，问至少要加多少才能使这三个边成为一个三角形。

思路：

找到最大的边，然后最大边 + 1减剩下两条边就行了。负数的话就是0。

 #include<iostream>
 #include<cmath>
 #include<algorithm>
 #include<stdio.h>
 #include<cstring>
 #include<vector>
 #include<map>
 #include<set>
 #include<bits/stdc++.h>

 #define inf 0x3f3f3f3f
 using namespace std;
 typedef long long LL;

 int a, b, c;

 int main(){

     while(scanf("%d%d%d", &a, &b, &c) != EOF){
         int m = max(a, b);
         m = max(m, c);
         int ans = ;
         if(m == a){
             if(b + c > m){
                 ans = ;
             }
             else{
                 ans = m +  - b - c;
             }
         }
         else if(m == b){
             if(a + c > m){
                 ans = ;
             }
             else{
                 ans = m +  - a - c;
             }
         }
         else{
             if(a + b > m){
                 ans = ;
             }
             else{
                 ans = m +  - a - b;
             }
         }
         printf("%d\n", ans);
     }
     return ;
 }

B---Equations of Mathematical Magic

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

题意：

给定一个a， 使得a - (a ^ x) - x = 0.问能有多少的x。

思路：

如果a的某一位是1， x的这一位是1，那么a^x这一位是0，a-（a^x)-x这一位是0

如果a的某一位是1， x的这一位是0， 那么a^x这一位是1，a-（a^x)-x这一位是0

如果a的某一位是0， x的这一位是1， 那么a^x这一位是1，a-（a^x)-x这一位是1

如果a的某一位是0， x的这一位是0，那么a^x这一位是0，a-（a^x)-x这一位是0

所以统计一下a的1的个数

 #include<iostream>
 #include<cmath>
 #include<algorithm>
 #include<stdio.h>
 #include<cstring>
 #include<vector>
 #include<map>
 #include<set>
 #include<bits/stdc++.h>

 #define inf 0x3f3f3f3f
 using namespace std;
 typedef long long LL;

 int t;
 LL a;

 int main(){

     while(scanf("%d", &t) != EOF){
         for(int i = ; i < t; i++){
             scanf("%I64d", &a);
             LL cnt = ;
             while(a){
                 if(a & ){
                     cnt <<= ;
                 }
                 a >>= ;
             }

             printf("%I64d\n", cnt);
         }

     }

     return ;
 }

C---Oh Those Palindromes

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

题意：

给定一个字符串，使得他的是回文的子串数目最多，问应如何重新排列这个字符串。

思路：

让同一个字母都放在一起，输出就行了。sort一下就行，但是我竟然还统计了一下个数，蠢了。

 #include<iostream>
 #include<cmath>
 #include<algorithm>
 #include<stdio.h>
 #include<cstring>
 #include<vector>
 #include<map>
 #include<set>
 #include<bits/stdc++.h>

 #define inf 0x3f3f3f3f
 using namespace std;
 typedef long long LL;

 int n;
 const int maxn = 1e5 + ;
 char str[maxn];
 int cnt[];

 int main(){

     while(scanf("%d", &n) != EOF){
         //scanf("%s", str);
         cin>>str;
         memset(cnt, , sizeof(cnt));
         for(int i = ; i < n; i++){
             cnt[str[i] - 'a']++;
         }
         for(int i = ; i < ; i++){
             for(int j = ; j < cnt[i]; j++){
                 printf("%c", i+'a');
             }
         }
         printf("\n");
     }
     return ;
 }

D---Labyrinth

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

题意：

一个n*m的格子，有的格子有障碍不能经过。现在从（r, c）处出发，向左最多只能走x次，向右最多走y次，问可以到达的格子有多少个。

思路：

最开始想的是dfs直接更新啥的。但是由于有先后顺序的问题，所以更新的时候左右的次数是不能直接减1的。需要用数组记录一下最大的左右次数。

而且如果发现vis过了这个格子就不更新了的话，也还是有先后顺序的问题。只有当经过这个格子的左右次数比原来大的时候才继续dfs更新这个格子。

但是这样dfs会T。

czc bfs过了，明天试一下....

先贴一下T了的代码。

 #include<iostream>
 #include<cmath>
 #include<algorithm>
 #include<stdio.h>
 #include<cstring>
 #include<vector>
 #include<map>
 #include<set>
 #include<bits/stdc++.h>

 #define inf 0x3f3f3f3f
 using namespace std;
 typedef long long LL;

 int n, m, r, c, x, y, cnt;
 const int maxn = ;
 bool vis[maxn][maxn];
 int leftl[maxn][maxn], leftr[maxn][maxn];
 int mvi[] = {, , , -};
 int mvj[] = {, -, , };
 bool g[maxn][maxn];

 void dfs(int posi, int posj)
 {
     if(!vis[posi][posj]){
         vis[posi][posj] = true;
         //cout<<posi<<" "<< posj<<endl;
         cnt++;
     }
     for(int k = ; k < ; k++){
         int di = posi + mvi[k];
         int dj = posj + mvj[k];
         int mostl,mostr;
         if(di >  && dj >  && di <= n && dj <= m && g[di][dj]){
             if(k == ){//向右
                 mostr = leftr[posi][posj] - ;
                 mostl = leftl[posi][posj];
                 if(mostr > leftr[di][dj] && mostr >= ){
                     leftr[di][dj] = mostr;
                     leftl[di][dj] = mostl;
                     dfs(di, dj);
                 }
             }
             else if(k == ){
                 mostl = leftl[posi][posj] - ;
                 mostr = leftr[posi][posj];
                 if(mostl > leftl[di][dj] && mostl >= ){
                     leftl[di][dj] = mostl;
                     leftr[di][dj] = mostr;
                     dfs(di, dj);
                 }
             }
             else{
                 mostl = leftl[posi][posj];
                 mostr = leftr[posi][posj];
                 if(mostl > leftl[di][dj]){
                     leftl[di][dj] = mostl;
                     leftr[di][dj] = mostr;
                     dfs(di, dj);
                 }
             }
         }
     }
 }

 int main(){

     while(scanf("%d%d", &n, &m) != EOF){
         scanf("%d%d", &r, &c);
         scanf("%d%d", &x, &y);
         cnt = ;
         memset(vis, , sizeof(vis));
         memset(leftr, -, sizeof(leftr));
         memset(leftl, -, sizeof(leftl));

         for(int i = ; i <= n; i++){
             char str[maxn];
             scanf("%s", str);
             for(int j = ; j < m; j++){
                 if(str[j] == '*'){
                     g[i][j + ] = false;
                 }
                 else{
                     g[i][j + ] = true;
                 }
             }
         }

         leftl[r][c] = x;
         leftr[r][c] = y;
         dfs(r, c);
         printf("%d\n", cnt);
     }
     return ;
 }

bfs写的 1A代码

 #include<iostream>
 #include<cmath>
 #include<algorithm>
 #include<stdio.h>
 #include<cstring>
 #include<vector>
 #include<map>
 #include<set>
 #include<bits/stdc++.h>

 #define inf 0x3f3f3f3f
 using namespace std;
 typedef long long LL;

 int n, m, r, c, x, y, cnt;
 const int maxn = ;
 bool vis[maxn][maxn];
 int leftl[maxn][maxn], leftr[maxn][maxn];
 int mvi[] = {, , , -};
 int mvj[] = {, -, , };
 bool g[maxn][maxn];

 void dfs(int posi, int posj)
 {
     if(!vis[posi][posj]){
         vis[posi][posj] = true;
         //cout<<posi<<" "<< posj<<endl;
         cnt++;
     }
     for(int k = ; k < ; k++){
         int di = posi + mvi[k];
         int dj = posj + mvj[k];
         int mostl,mostr;
         if(di >  && dj >  && di <= n && dj <= m && g[di][dj]){
             if(k == ){//ÏòÓÒ
                 mostr = leftr[posi][posj] - ;
                 mostl = leftl[posi][posj];
                 if(mostr > leftr[di][dj] && mostr >= ){
                     leftr[di][dj] = mostr;
                     leftl[di][dj] = mostl;
                     dfs(di, dj);
                 }
             }
             else if(k == ){
                 mostl = leftl[posi][posj] - ;
                 mostr = leftr[posi][posj];
                 if(mostl > leftl[di][dj] && mostl >= ){
                     leftl[di][dj] = mostl;
                     leftr[di][dj] = mostr;
                     dfs(di, dj);
                 }
             }
             else{
                 mostl = leftl[posi][posj];
                 mostr = leftr[posi][posj];
                 if(mostl > leftl[di][dj]){
                     leftl[di][dj] = mostl;
                     leftr[di][dj] = mostr;
                     dfs(di, dj);
                 }
             }
         }
     }
 }

 struct node{
     int i, j;
     node(){}
     node(int _i, int _j):i(_i), j(_j){}
 };

 void bfs()
 {
     queue<node>que;
     que.push(node(r, c));
     vis[r][c] = true;
     cnt = ;
     while(!que.empty()){
         node now = que.front();
         que.pop();
         for(int k = ; k < ; k++){
             int di = now.i + mvi[k], dj = now.j + mvj[k];
             if(di >  && di <= n && dj >  && dj <= m && g[di][dj]){
                 /*if(!vis[di][dj]){
                     vis[di][dj] = true;
                     cnt++;
                 }*/
                 if(k == ){
                     int mostl = leftl[now.i][now.j], mostr = leftr[now.i][now.j] - ;
                     if(mostr >=  && !vis[di][dj]){
                         vis[di][dj] = true;
                         cnt++;
                     }
                     if(mostr >=  && mostr > leftr[di][dj]){
                         que.push(node(di, dj));
                         leftl[di][dj] = mostl;
                         leftr[di][dj] = mostr;
                     }
                 }
                 else if(k == ){
                     int mostl = leftl[now.i][now.j] - , mostr = leftr[now.i][now.j];
                     if(mostl >=  && !vis[di][dj]){
                         vis[di][dj] = true;
                         cnt++;
                     }
                     if(mostl >=  && mostl > leftl[di][dj]){
                         que.push(node(di, dj));
                         leftl[di][dj] = mostl;
                         leftr[di][dj] = mostr;
                     }
                 }
                 else{
                     int mostl = leftl[now.i][now.j], mostr = leftr[now.i][now.j];
                     if(!vis[di][dj]){
                         vis[di][dj] = true;
                         cnt++;
                     }
                     if(mostl > leftl[di][dj]){
                         que.push(node(di, dj));
                         leftl[di][dj] = mostl;
                         leftr[di][dj] = mostr;
                     }
                 }
             }
         }
     }
     printf("%d\n", cnt);
 }

 int main(){

     while(scanf("%d%d", &n, &m) != EOF){
         scanf("%d%d", &r, &c);
         scanf("%d%d", &x, &y);
         cnt = ;
         memset(vis, , sizeof(vis));
         memset(leftr, -, sizeof(leftr));
         memset(leftl, -, sizeof(leftl));

         for(int i = ; i <= n; i++){
             char str[maxn];
             scanf("%s", str + );
             for(int j = ; j <= m; j++){
                 if(str[j] == '*'){
                     g[i][j] = false;
                 }
                 else{
                     g[i][j] = true;
                 }
             }
         }

         leftl[r][c] = x;
         leftr[r][c] = y;
         bfs();
         //cout<<"!"<<endl;
         //dfs(r, c);
         //printf("%d\n", cnt);
     }
     return ;
 }

上了31分，ABC都卡了一下，C还RE了一发，还是太菜了啊。