Codeforces Round #286 (Div. 2)

A题。。暴力枚举在每个位置添加字符,然后检查一下是不是回文串

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstring>
 4 #include <algorithm>
 5 #include <cmath>
 6 #include <vector>
 7
 8 using namespace std;
 9
10 #define LL long long
11 #define eps 1e-8
12 #define inf 0x3f3f3f3f
13 #define lson l, m, rt << 1
14 #define rson m+1, r, rt << 1 | 1
15 #define mnx 31000
16
17 char s[20], ch[20];
18 bool check(){
19     int n = strlen( ch );
20     for( int i = 0, j = n-1; i <= j; ++i, --j ){
21         if( ch[i] != ch[j] ) return false;
22     }
23     return true;
24 }
25 int main(){
26     scanf( "%s", &s );
27     int n = strlen( s );
28     for( int i = 0; i <= n; ++i ){
29         for( int j = ‘a‘; j <= ‘z‘; ++j ){
30             for( int k = 0, m = 0; k <= n; ++k ){
31                 if( i == k )
32                     ch[k] = (char)j;
33                 else
34                     ch[k] = s[m++];
35             }
36             ch[n+1] = ‘\0‘;
37             if( check() ){
38                 printf( "%s\n", ch );
39                 return 0;
40             }
41         }
42     }
43     puts( "NA" );
44     return 0;
45 }

B题。。也是暴力枚举每种颜色,dfs算一下就好

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstring>
 4 #include <algorithm>
 5 #include <cmath>
 6 #include <vector>
 7
 8 using namespace std;
 9
10 #define LL long long
11 #define eps 1e-8
12 #define inf 0x3f3f3f3f
13 #define lson l, m, rt << 1
14 #define rson m+1, r, rt << 1 | 1
15 #define mnx 500
16
17 int fst[mnx], nxt[mnx], vv[mnx], col[mnx], e, ans;
18 void add( int u, int v, int c ){
19     vv[e] = v, col[e] = c, nxt[e] = fst[u], fst[u] = e++;
20 }
21 bool vis[mnx], ok;
22 void dfs( int u, int gg, int vol ){
23     if( u == gg ){
24         ans++; ok = 1; return ;
25     }
26     if( vis[u] ) return ;
27     vis[u] = 1;
28     for( int i = fst[u]; i != -1; i = nxt[i] ){
29         if( ok ) return ;
30         int v = vv[i], c = col[i];
31         if( c != vol ) continue;
32         dfs( v, gg, vol );
33     }
34 }
35 int main(){
36     int n, m, q;
37     scanf( "%d %d", &n, &m );
38     memset( fst, -1, sizeof( fst ) );
39     for( int i = 0; i < m; ++i ){
40         int u, v, c;
41         scanf( "%d %d %d", &u, &v, &c );
42         add( u, v, c );
43         add( v, u, c );
44     }
45     scanf( "%d", &q );
46     while( q-- ){
47         int u, v;
48         scanf( "%d%d", &u, &v );
49         ans = 0;
50         for( int i = 1; i <= m; ++i ){
51             memset( vis, 0, sizeof( vis ) );
52             ok = 0;
53             dfs( u, v, i );
54         }
55         cout << ans << endl;
56     }
57     return 0;
58 }

C题。。比赛的时候想不出来,看了题解才知道 第二维的状态最多不超过500。。因为你1+2+...+250 > 3w,这样每次步数减一或者加一的总的状态不会超过500,所以dp[30000][600]就够了, 把第二维300当做第一次的步数d,然后每次有可能走 d+j-n - 1, d+j-n, d+j-n+1步,感觉看代码容易理解一些。。

 1 #include <iostream>
 2 #include <cstdio>
 3 #include <cstring>
 4 #include <algorithm>
 5 #include <cmath>
 6 #include <vector>
 7
 8 using namespace std;
 9
10 #define LL long long
11 #define eps 1e-8
12 #define inf 0x3f3f3f3f
13 #define lson l, m, rt << 1
14 #define rson m+1, r, rt << 1 | 1
15 #define mnx 31000
16
17 const int N = 300;
18 int dp[mnx][700], val[mnx];
19 int main(){
20     int n, m;
21     while( scanf( "%d%d", &n, &m ) != EOF ){
22         memset( val, 0, sizeof val );
23         memset( dp, 0, sizeof dp );
24         for( int i = 0; i < n; ++i ){
25             int x;
26             scanf( "%d", &x );
27             val[x]++;
28         }
29         dp[m][N] = val[m] + val[0] + 1;
30         int ans = 0;
31         for( int i = m; i < mnx; ++i ){
32             for( int j = 0; j < 600; ++j ){
33                 if( !dp[i][j] ) continue;
34                 int l = m + j - N;
35                 ans = max( dp[i][j] - 1, ans );
36                 if( i + l >= mnx ) continue;
37                 if( l > 0 )
38                     dp[i+l][j] = max( dp[i+l][j], dp[i][j] + val[i+l] );
39                 if( l > 1 )
40                     dp[i+l-1][j-1] = max( dp[i+l-1][j-1], dp[i][j] + val[i+l-1] );
41                 if( l >= 0 )
42                     dp[i+l+1][j+1] = max( dp[i+l+1][j+1], dp[i][j] + val[i+l+1] );
43             }
44         }
45         cout << ans << endl;
46     }
47     return 0;
48 }

D题。。好像是B的加强版,用并查集搞。。明天再看看

时间: 2024-10-10 13:53:28

Codeforces Round #286 (Div. 2)的相关文章

Codeforces Round #286 div.1 D 506D D. Mr. Kitayuta&#39;s Colorful Graph【并查集】

题目链接:http://codeforces.com/problemset/problem/506/D 题目大意: 给出n个顶点,m条边,每条边上有一个数字,代表某个颜色.不同数字代表不同的颜色.有很多个询问,每个询问问有多少条纯种颜色的路径使得某两个点联通. 分析: 这个题一看就想用并查集来搞,每种颜色用一个并查集处理.对于输入的每条边,我们只需要将这两个点在这条边的颜色对应的并查集中合并就好了.查询的时候,我们只需要检测这两个点在多少个颜色对应的并查集中是在统一集合中的,那么就有多少条纯种颜

Codeforces Round #286 (Div. 2)B. Mr. Kitayuta&#39;s Colorful Graph(dfs,暴力)

数据规模小,所以就暴力枚举每一种颜色的边就行了. #include<iostream> #include<cstdio> #include<cstdlib> #include<cstring> #include<string> #include<cmath> #include<map> #include<set> #include<vector> #include<algorithm>

Codeforces Round #286 div.2 D 505D. Mr. Kitayuta&#39;s Technology【强连通分量,弱联通分量】

题目链接:http://codeforces.com/contest/505/problem/D 题目大意: 在一个图中,有n个顶点,给出m对数字(u,v)表示顶点u和顶点v必须直接或者间接相连,让你构造一个这样的图,输出最少需要多少条边. 分析: 毫无疑问,n个顶点的话,我们最多可以用n条边,使得n个顶点构成一个环,满足所有的情况(任意两点都是联通的),但是这并不一定是最少的边. 于是我们还需要找一个方法确定最少需要多少条边. 首先我们利用题目给出的点对建图,得到图G.对于G中的弱联通分量来说

Codeforces Round #286 (Div. 2)A. Mr. Kitayuta&#39;s Gift(暴力,string的应用)

由于字符串的长度很短,所以就暴力枚举每一个空每一个字母,出现行的就输出.这么简单的思路我居然没想到,临场想了很多,以为有什么技巧,越想越迷...是思维方式有问题,遇到问题先分析最简单粗暴的办法,然后一步一步的优化,不能盲目的想. 这道题要AC的快需要熟悉string的各种用法.这里做个简单总结:C++中string的常见用法. #include<iostream> #include<cstdio> #include<cstdlib> #include<cstrin

Codeforces Round #286 (Div. 2) B. Mr. Kitayuta&#39;s Colorful Graph +foyd算法的应用

B. Mr. Kitayuta's Colorful Graph time limit per test 1 second memory limit per test 256 megabytes input standard input output standard output Mr. Kitayuta has just bought an undirected graph consisting of n vertices and m edges. The vertices of the g

水题 Codeforces Round #286 (Div. 2) A Mr. Kitayuta&#39;s Gift

题目传送门 1 /* 2 水题:vector容器实现插入操作,暴力进行判断是否为回文串 3 */ 4 #include <cstdio> 5 #include <iostream> 6 #include <algorithm> 7 #include <cstring> 8 #include <string> 9 #include <vector> 10 using namespace std; 11 12 const int MAXN

DFS/并查集 Codeforces Round #286 (Div. 2) B - Mr. Kitayuta&#39;s Colorful Graph

题目传送门 1 /* 2 题意:两点之间有不同颜色的线连通,问两点间单一颜色连通的路径有几条 3 DFS:暴力每个颜色,以u走到v为结束标志,累加条数 4 注意:无向图 5 */ 6 #include <cstdio> 7 #include <iostream> 8 #include <algorithm> 9 #include <cstring> 10 #include <string> 11 #include <vector> 1

Codeforces Round #286 (Div. 1) D. Mr. Kitayuta&#39;s Colorful Graph

D - Mr. Kitayuta's Colorful Graph 思路:我是暴力搞过去没有将答案离线,感觉将答案的离线的方法很巧妙.. 对于一个不大于sqrt(n) 的块,我们n^2暴力枚举, 对于大于sqrt(n)的块,我们暴力枚举答案. 这样就能做到严格sqrt(n) * n #include<bits/stdc++.h> #define LL long long #define fi first #define se second #define mk make_pair #defin

Codeforces Round #286 (Div. 1) A. Mr. Kitayuta, the Treasure Hunter DP

链接: http://codeforces.com/problemset/problem/506/A 题意: 给出30000个岛,有n个宝石分布在上面,第一步到d位置,每次走的距离与上一步的差距不大于1,问走完一路最多捡到多少块宝石. 题解: 容易想到DP,dp[i][j]表示到达 i 处,现在步长为 j 时最多收集到的财富,转移也不难,cnt[i]表示 i 处的财富. dp[i+step-1] = max(dp[i+step-1],dp[i][j]+cnt[i+step+1]) dp[i+st

Codeforces Round #286 (Div. 1 B)

http://codeforces.com/contest/506/problem/B Problem 一个图还有N个点,给M个关系 < a,b >,表示a必须要到达b,关系满足传递性,即a->b,b->c,则a->c.同时,a到b,b不一定要到a.问,最少要加多少条边,使得每个关系都成立. Solution 对于一个N个点的图,由于边是有传递性的,不妨把N个点连成一个环,那么一定可以两两相互到达,但这不一定是最少的.对于一个弱联通图,含有n个点,如果它不存在环(是一个DAG