├── 201312-1 出现次数最多的数 ccf.cpp
├── 201312-2 ISBN号码 ccf .cpp
├── 201312-3 最大的矩形 ccf .cpp
├── 201312-4 有趣的数 ccf.cpp
├── 201403-1 相反数 ccf .cpp
├── 201403-2 窗口 ccf .cpp
├── 201403-3 命令行选项 ccf .cpp
├── 201403-4 无线网络 ccf.cpp
├── 201409-1 相邻数对 ccf .cpp
├── 201409-2 画图 ccf .cpp
├── 201409-3 字符串匹配 ccf .cpp
├── 201409-4 最优配餐 ccf.cpp
├── 201412-1 门禁系统 ccf .cpp
├── 201412-2 Z字形扫描 ccf .cpp
├── 201412-3 集合竞价 ccf .cpp
├── 201412-4 最优灌溉 ccf .cpp
├── 201503-1 图像旋转 ccf .cpp
├── 201503-2 数字排序 ccf .cpp
├── 201503-3 节日 ccf .cpp
├── 201503-4 网络延时 ccf.cpp
├── 201509-1 数列分段 ccf .cpp
├── 201509-2 日期计算 ccf .cpp
├── 201509-3 模板生成系统 ccf .cpp
├── 201509-4 高速公路 ccf .cpp
├── 201512-1 数位之和 ccf.cpp
├── 201512-2 消除类游戏 ccf .cpp
├── 201512-3 画图 ccf .cpp
├── 201512-4 送货 ccf .cpp
├── 201604-1 折点计数 ccf.cpp
├── 201604-2 俄罗斯方块 ccf .cpp
├── 201604-4 游戏 ccf.cpp
├── 201609-1 最大波动 ccf.cpp
├── 201609-2 火车购票 ccf.cpp
├── 201609-3 炉石传说 ccf .cpp
├── 201609-4 交通规划 ccf.cpp
├── 201612-1 中间数 ccf.cpp
├── 201612-2 工资计算 ccf .cpp
├── 201612-3 权限查询 ccf .cpp
├── 201612-4 压缩编码 ccf .cpp
├── 201703-1 分蛋糕 ccf .cpp
├── 201703-2 学生排队 ccf .cpp
├── 201703-3 Markdown ccf .cpp
├── 201703-4 地铁修建 ccf .cpp
├── 201709-1 打酱油 ccf .cpp
├── 201709-2 公共钥匙盒 ccf .cpp
├── 201709-3 JSON查询 ccf .cpp
├── 201709-4 通信网络 ccf .cpp
├── 201709-5 除法 ccf .cpp
├── 201712-1 最小差值 ccf.cpp
├── 201712-2 游戏 ccf.cpp
├── 201712-3 Crontab ccf.cpp
├── 201712-4 行车路线 ccf.cpp
├── 201803-1 跳一跳 ccf.cpp
├── 201803-2 碰撞的小球 ccf.cpp
├── 201803-3 URL映射 ccf.cpp
├── 201803-4 棋局评估 ccf.cpp
├── 201809-1 卖菜 ccf.cpp
├── 201809-2 买菜 ccf.cpp
├── 201809-3 元素选择器 ccf.cpp
├── 201809-4 再卖菜 ccf.cpp
├── 201812-1 小明上学 ccf.cpp
└── README.md


/201312-1 出现次数最多的数 ccf.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int v[11024];
 4 | int main()
 5 | {
 6 |     int n,maxcnt=-1;
 7 |     cin>>n;
 8 |     for(int i=0;i<n;++i)
 9 |     {
10 |         int x;
11 |         cin>>x;
12 |         v[x]++;
13 |     }
14 |     for(int i=1;i<=10000;++i)
15 |         maxcnt=max(maxcnt,v[i]);
16 |     for(int i=1;i<=10000;++i)
17 |     {
18 |         if(maxcnt==v[i])
19 |         {
20 |             cout<<i<<endl;
21 |             break;
22 |         }
23 |     }
24 |     return 0;
25 | }
26 | 


--------------------------------------------------------------------------------
/201312-2 ISBN号码 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | char val(int x)
 4 | {
 5 |     return x%11==10?'X':'0'+x%11;
 6 | }
 7 | int main()
 8 | {
 9 |     char ch,ibsn[16];
10 |     int k=0,sum=0,cnt;
11 |     while((ch=cin.get())!='\n')
12 |     {
13 |         ibsn[k++]=ch;
14 |         if(isdigit(ch))
15 |         {
16 |             ++cnt;
17 |             if(cnt<=9) sum+=(ch-'0')*cnt;
18 |         }
19 |     }
20 |     ibsn[k]='\0';
21 |     char x=val(sum);
22 |     if(ibsn[k-1]==x)
23 |         printf("Right\n");
24 |     else
25 |     {
26 |         ibsn[k-1]=x;
27 |         printf("%s\n",ibsn);
28 |     }
29 |     return 0;
30 | }
31 | 


--------------------------------------------------------------------------------
/201312-3 最大的矩形 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int val[1024];
 4 | int main()
 5 | {
 6 |     int n,ans=-1;
 7 |     scanf("%d",&n);
 8 |     for(int i=1;i<=n;++i)
 9 |         scanf("%d",&val[i]);
10 |     for(int i=1;i<=n;++i)
11 |     {
12 |         int v=val[i];
13 |         for(int j=i+1;j<=n;++j)
14 |         {
15 |             v=min(v,val[j]);
16 |             ans=max(v*(j-i+1),ans);
17 |         }
18 |     }
19 |     cout<<ans;
20 |     return 0;
21 | }
22 | 


--------------------------------------------------------------------------------
/201312-4 有趣的数 ccf.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | 考察点是动态规划
 3 | 题目给出了0，1，2，3四个数，现考察一系列中间状态，即选取四个数的子集，在满足题设条件下，共有如下6种状态
 4 | 状态0：2 
 5 | 状态1：0 2 
 6 | 状态2：2 3 
 7 | 状态3：0 1 2 
 8 | 状态4：0 2 3 
 9 | 状态5：0 1 2 3 
10 | 最终我们需要求得的结果是状态5，用sta[i][j]表示一系列中间过程，其中i表示数的位数，j表示状态
11 | 显然，i=0时，所有的不同结果都为0（边界条件）
12 | 对于状态0来说，所选取的集合只有2，所以对于任意数位n，其不同个数始终为1
13 | 对于状态1来说，数位为i时的结果可以通过第i-1位状态获得，包括
14 | 			  (1)通过状态0获得，只能在第i位时添加0，即sta[i-1][0]
15 | 			  (2)通过本身状态1获得，在第i位添加0或者2，即sta[i-1][1]*2
16 | 			  所以，sta[i][1]=sta[i-1][0]+sta[i-1][1]*2
17 | 对于状态2来说，数位为i时的结果可以通过第i-1位状态获得，包括
18 | 			  (1)通过状态0获得，只能在第i位时添加3，即sta[i-1][0]
19 | 			  (2)通过本身状态2获得，只能在第i位添加3，即sta[i-1][2]
20 | 			  所以，sta[i][2]=sta[i-1][0]+sta[i-1][2]
21 | 其余状态同理，也即是，对于任意状态，总可以通过前序状态或者本身状态获得
22 | 所有转移方程如下
23 | sta[i][0]=1
24 | sta[i][1]=sta[i-1][0]+sta[i-1][1]*2
25 | sta[i][2]=sta[i-1][0]+sta[i-1][2]
26 | sta[i][3]=sta[i-1][1]+sta[i-1][3]*2
27 | sta[i][4]=sta[i-1][1]+sta[i-1][2]+sta[i-1][4]*2
28 | sta[i][5]=sta[i-1][3]+sta[i-1][4]+sta[i-1][5]*2
29 | 
30 | 对状态的补充：
31 | 一个数情况，必须是2（首位必须是2）
32 | 		   (0)2
33 | 两个数情况，必须有2，其余只能是0，3（0必须在1前面）
34 | 		   (1)0 2
35 | 		   (2)2 3
36 | 三个数情况，必须有2，其余可能是0，1或者0，3
37 | 		   (3)0 1 2
38 | 		   (4)0 2 3
39 | 四个数情况，(5)0 1 2 3
40 | 6种状态整理完毕
41 | */
42 | #include <bits/stdc++.h>
43 | using namespace std;
44 | typedef long long llt;
45 | const llt mod=1000000007;
46 | llt sta[1024][6],n;
47 | int main()
48 | {
49 | 	scanf("%lld",&n);
50 | 	for(llt i=1;i<=n;++i)
51 | 	{
52 | 		sta[i][0]=1;
53 | 		sta[i][1]=(sta[i-1][0]+sta[i-1][1]*2)%mod;
54 | 		sta[i][2]=(sta[i-1][0]+sta[i-1][2])%mod;
55 | 		sta[i][3]=(sta[i-1][1]+sta[i-1][3]*2)%mod;
56 | 		sta[i][4]=(sta[i-1][1]+sta[i-1][2]+sta[i-1][4]*2)%mod;
57 | 		sta[i][5]=(sta[i-1][3]+sta[i-1][4]+sta[i-1][5]*2)%mod;
58 | 	}
59 | 	printf("%lld\n",sta[n][5]);
60 | 	return 0;
61 | }
62 | 


--------------------------------------------------------------------------------
/201403-1 相反数 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <algorithm>
 3 | using namespace std;
 4 | int main()
 5 | {
 6 |     int a[1024]={0},n,cnt=0;
 7 |     cin>>n;
 8 |     for(int i=0;i<n;++i)
 9 |     {
10 |         int x;
11 |         cin>>x;
12 |         a[abs(x)]++;
13 |     }
14 |     for(int i=0;i<=1000;++i)
15 |         if(a[i]==2)++cnt;
16 |     cout<<cnt;
17 |     return 0;
18 | }
19 | 


--------------------------------------------------------------------------------
/201403-2 窗口 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | struct window
 4 | {
 5 |     int x1,y1;
 6 |     int x2,y2;
 7 |     int num;
 8 |     window(int a=0,int b=0,int c=0,int d=0,int x=0):x1(a),y1(b),x2(c),y2(d),num(x){}
 9 | };
10 | vector<window> v;
11 | bool check(int x,int y,window &w)
12 | {
13 |     if(x>=w.x1&&y>=w.y1&&x<=w.x2&&y<=w.y2)
14 |         return true;
15 |     return false;
16 | }
17 | void search(int x,int y)
18 | {
19 |     size_t i=0;
20 |     while(i<v.size())
21 |     {
22 |         if(check(x,y,v[i]))
23 |         {
24 |             window temp=v[i];
25 |             v.erase(v.begin()+i);
26 |             v.insert(v.begin(),temp);
27 |             cout<<temp.num<<endl;
28 |             return;
29 |         }
30 |         ++i;
31 |     }
32 |     cout<<"IGNORED\n";
33 | }
34 | int main()
35 | {
36 |     int n,m;
37 |     cin>>n>>m;
38 |     v.resize(n);
39 |     for(int i=n-1;i>=0;--i)
40 |     {
41 |         int x1,y1,x2,y2;
42 |         cin>>x1>>y1>>x2>>y2;
43 |         v[i]=window(x1,y1,x2,y2,n-i);
44 |     }
45 |     while(m--)
46 |     {
47 |         int x,y;
48 |         cin>>x>>y;
49 |         search(x,y);
50 |     }
51 |     return 0;
52 | }
53 | 


--------------------------------------------------------------------------------
/201403-3 命令行选项 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | map<string,int> mcmd;
 4 | map<string,string> m;
 5 | string nextsplit(string &str)
 6 | {
 7 |     size_t pos=str.find(" ");
 8 |     string ans;
 9 |     if(pos==string::npos){
10 |         ans=str;
11 |         str="";
12 |         return ans;
13 |     }
14 |     ans=str.substr(0,pos);
15 |     str=str.substr(pos+1);
16 |     return ans;
17 | }
18 | void deal(string str)
19 | {
20 |     m.clear();
21 |     nextsplit(str);
22 |     while(str.size()>0){
23 |         string x=nextsplit(str);
24 |         if(mcmd.count(x+":")>0&&str.size()>0){
25 |             string next=nextsplit(str);
26 |             //if(next[0]=='-')return;此处多考虑了，是合法的
27 |             m[x]=next;
28 |             continue;
29 |         }
30 |         if(mcmd.count(x)>0){
31 |             m[x]="";
32 |             continue;
33 |         }
34 |         return;
35 |     }
36 |     return;
37 | }
38 | int main()
39 | {
40 |     int n;
41 |     string cmd;
42 |     cin>>cmd;
43 |     for(size_t i=0;i<cmd.size();++i){
44 |         if(i<cmd.size()-1&&cmd[i+1]==':'){
45 |             mcmd['-'+string(1,cmd[i])+cmd[i+1]]=1;
46 |             i++;
47 |         }
48 |         else{
49 |             mcmd['-'+string(1,cmd[i])]=1;
50 |         }
51 |     }
52 |     cin>>n;
53 |     cin.get();
54 |     for(int i=1;i<=n;++i)
55 |     {
56 |         string str;
57 |         getline(cin,str);
58 |         deal(str);
59 |         cout<<"Case "<<i<<":";
60 |         map<string,string>::iterator it=m.begin();
61 |         while(it!=m.end())
62 |         {
63 |             cout<<" "<<it->first;
64 |             if(it->second!="")
65 |                 cout<<" "<<it->second;
66 |             ++it;
67 |         }
68 |         cout<<endl;
69 |     }
70 |     return 0;
71 | }
72 | 


--------------------------------------------------------------------------------
/201403-4 无线网络 ccf.cpp:
--------------------------------------------------------------------------------
 1 | /*
 2 | 这里k值貌似没有太大用处，所以其实不记录counts也是可以的，
 3 | 通过bfs策略得到的一定最优的，所以一定是满足小于等于k的，除非存在不合法例
 4 | */
 5 | #include <bits/stdc++.h>
 6 | using namespace std;
 7 | typedef long long llt;
 8 | struct node
 9 | {
10 | 	int x,y;
11 | 	int vertexnum;
12 | 	int counts;
13 | 	node(int a,int b,int vn,int c):x(a),y(b),vertexnum(vn),counts(c){}
14 | };
15 | vector<node> v;
16 | bool matrix[256][256];
17 | bool visit[256];
18 | bool isConnect(node &a,node &b,int r)//在r范围内
19 | {
20 | 	return (llt)(a.x-b.x)*(a.x-b.x)+(llt)(a.y-b.y)*(a.y-b.y)<=(llt)r*r;
21 | }
22 | int main()
23 | {
24 | 	int n,m,k,r;
25 | 	scanf("%d %d %d %d",&n,&m,&k,&r);
26 | 	for(int i=0;i<n+m;++i)
27 | 	{
28 | 		int x,y;
29 | 		scanf("%d %d",&x,&y);
30 | 		v.push_back(node(x,y,i,0));
31 | 	}
32 | 	for(int i=0;i<n+m;++i)//创建邻接矩阵matrix
33 | 	{
34 | 		for(int j=0;j<n+m;++j)
35 | 		{
36 | 			matrix[i][j]=isConnect(v[i],v[j],r);
37 | 		}
38 | 	}
39 | 	queue<node> q;
40 | 	q.push(v[0]);
41 | 	int elecnt=1,level=1;
42 | 	while(elecnt>0)//bfs
43 | 	{
44 | 		int nextelecnt=0;//记录下一层次元素个数
45 | 		for(int i=0;i<elecnt;++i)
46 | 		{
47 | 			node cur=q.front();
48 | 			q.pop();
49 | 			if(cur.vertexnum==1)//是第二个路由器，得到结果
50 | 			{
51 | 				printf("%d\n",level-2);
52 | 				return 0;
53 | 			}
54 | 			int w=cur.vertexnum,u=0;
55 | 			while(u<m+n)//依次遍历n+m个节点
56 | 			{
57 | 				if(matrix[w][u]&&!visit[u]&&cur.counts<=k)
58 | 				{
59 | 					visit[u]=true;
60 | 					v[u].counts=(u>=n)?cur.counts+1:cur.counts;
61 | 					q.push(v[u]);
62 | 					++nextelecnt;
63 | 				}
64 | 				++u;
65 | 			}
66 | 		}
67 | 		elecnt=nextelecnt;
68 | 		++level;
69 | 	}
70 | 	return 0;
71 | }
72 | 


--------------------------------------------------------------------------------
/201409-1 相邻数对 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     vector<int> v;
 6 |     int n,x;
 7 |     cin>>n;
 8 |     while(n--)
 9 |     {
10 |         cin>>x;
11 |         v.push_back(x);
12 |     }
13 |     sort(v.begin(),v.end());
14 |     size_t i=0,cnt=0;
15 |     while(i<v.size()-1)
16 |     {
17 |         while(i<v.size()-1&&v[i+1]-v[i]==1)
18 |         {
19 |             ++i;++cnt;
20 |         }
21 |         ++i;
22 |     }
23 |     cout<<cnt;
24 |     return 0;
25 | }
26 | 


--------------------------------------------------------------------------------
/201409-2 画图 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int matrix[128][128];
 4 | int main()
 5 | {
 6 |     int n,cnt=0;
 7 |     cin>>n;
 8 | 
 9 |     while(n--)
10 |     {
11 |         int x1,y1,x2,y2;
12 |         cin>>x1>>y1>>x2>>y2;
13 |         for(int i=x1;i<x2;++i)
14 |         {
15 |             for(int j=y1;j<y2;++j)
16 |                 matrix[i][j]=1;
17 |         }
18 |     }
19 |     for(int i=0;i<=100;++i){
20 |         for(int j=0;j<=100;++j){
21 |             if(matrix[i][j]==1)++cnt;
22 |         }
23 |     }
24 |     cout<<cnt;
25 |     return 0;
26 | }
27 | 


--------------------------------------------------------------------------------
/201409-3 字符串匹配 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     string x;
 6 |     int tag,n;
 7 |     cin>>x>>tag>>n;
 8 |     while(n--){
 9 |         string str;
10 |         cin>>str;
11 |         if(tag==1){
12 |             size_t pos=str.find(x);
13 |             if(pos!=string::npos){
14 |                 cout<<str<<endl;
15 |             }
16 |         }
17 |         else{
18 |             string temp,tx;
19 |             for(size_t i=0;i<str.size();++i){
20 |                 temp+=tolower(str[i]);
21 |             }
22 |             for(size_t i=0;i<x.size();++i){
23 |                 tx+=tolower(x[i]);
24 |             }
25 |             size_t pos=temp.find(tx);
26 |             if(pos!=string::npos){
27 |                 cout<<str<<endl;
28 |             }
29 |         }
30 |     }
31 |     return 0;
32 | }
33 | 


--------------------------------------------------------------------------------
/201409-4 最优配餐 ccf.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | typedef long long llt;
 4 | struct node
 5 | {
 6 | 	int x,y;
 7 | 	llt distance;
 8 | 	node(int a,int b,llt dis):x(a),y(b),distance(dis){}
 9 | };
10 | queue<node> q;
11 | int posNum[1024][1024];
12 | bool visit[1024][1024];
13 | int dx[]={1,0,-1,0};
14 | int dy[]={0,1,0,-1};
15 | int n,k,m,d;
16 | bool islegal(int x,int y)
17 | {
18 | 	return x>=1&&x<=n&&y>=1&&y<=n;
19 | }
20 | int main()
21 | {
22 | 	scanf("%d %d %d %d",&n,&k,&m,&d);
23 | 	for(int i=0;i<k;++i)
24 | 	{
25 | 		int x,y;
26 | 		scanf("%d %d",&x,&y);
27 | 		q.push(node(x,y,0));
28 | 		visit[x][y]=1;
29 | 	}
30 | 	for(int i=0;i<m;++i)
31 | 	{
32 | 		int x,y,nums;
33 | 		scanf("%d %d %d",&x,&y,&nums);
34 | 		posNum[x][y]=nums;
35 | 	}
36 | 	for(int i=0;i<d;++i)
37 | 	{
38 | 		int x,y;
39 | 		scanf("%d %d",&x,&y);
40 | 		visit[x][y]=1;
41 | 	}
42 | 	llt ret=0;
43 | 	while(!q.empty())
44 | 	{
45 | 		node cur=q.front();
46 | 		q.pop();
47 | 		for(int i=0;i<4;++i)
48 | 		{
49 | 			int x=cur.x+dx[i],y=cur.y+dy[i],dis=cur.distance;
50 | 			if(islegal(x,y)&&!visit[x][y])
51 | 			{
52 | 				ret+=posNum[x][y]*(dis+1);
53 | 				visit[x][y]=1;
54 | 				q.push(node(x,y,dis+1));
55 | 			}
56 | 		}
57 | 	}
58 | 	printf("%lld\n",ret);
59 | 	return 0;
60 | }
61 | 


--------------------------------------------------------------------------------
/201412-1 门禁系统 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int cnt[1024]={0},n,a[1024]={0};
 6 |     cin>>n;
 7 |     for(int i=0;i<n;++i)
 8 |     {
 9 |         int x;
10 |         cin>>x;
11 |         cnt[x]++;
12 |         a[i]=cnt[x];
13 |     }
14 |     for(int i=0;i<n;++i)
15 |         cout<<a[i]<<" ";
16 |     return 0;
17 | }
18 | 


--------------------------------------------------------------------------------
/201412-2 Z字形扫描 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int n,k=0,a[512][512];
 4 | vector<int> v[1024];
 5 | void help(int i,int j,int k)
 6 | {
 7 |     while(i>=0&&i<n&&j>=0&&j<n)
 8 |         v[k].push_back(a[i++][j--]);
 9 | }
10 | void ser()
11 | {
12 |     for(int j=0;j<n;++j)
13 |         help(0,j,k++);
14 |     for(int i=1;i<n;++i)
15 |         help(i,n-1,k++);
16 | }
17 | int main()
18 | {
19 | 
20 |     cin>>n;
21 |     for(int i=0;i<n;++i)
22 |     {
23 |         for(int j=0;j<n;++j)
24 |             cin>>a[i][j];
25 |     }
26 |     ser();
27 |     for(int i=0;i<k;++i)
28 |     {
29 |         if(i%2){
30 |             for(size_t j=0;j<v[i].size();++j)
31 |                 cout<<v[i][j]<<" ";
32 |         }
33 |         else{
34 |             for(int j=v[i].size()-1;j>=0;--j)
35 |                 cout<<v[i][j]<<" ";
36 |         }
37 |     }
38 |     return 0;
39 | }
40 | 


--------------------------------------------------------------------------------
/201412-3 集合竞价 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | struct record
 4 | {
 5 |     string opt;
 6 |     double price;
 7 |     int amount;
 8 |     bool isvalid;
 9 | }rec[5004];
10 | int main()
11 | {
12 |     //freopen("1.txt","r",stdin);
13 |     int i=0;
14 |     while(cin>>rec[i].opt){
15 |         if(rec[i].opt=="cancel"){
16 |             rec[i].isvalid=false;
17 |             int x;
18 |             cin>>x;
19 |             rec[x-1].isvalid=false;
20 |             ++i;
21 |             continue;
22 |         }
23 |         cin>>rec[i].price>>rec[i].amount;
24 |         rec[i].isvalid=true;
25 |         ++i;
26 |     }
27 |     int n=i;
28 |     set<double> pst;
29 |     for(i=0;i<n;++i){
30 |         if(rec[i].isvalid){
31 |             pst.insert(rec[i].price);
32 |         }
33 |     }
34 |     double ansp=0.0;
35 |     long long maxsum=0;
36 |     for(set<double>::iterator it=pst.begin();it!=pst.end();++it){
37 |         double p=*it;
38 |         long long sumbuy=0,sumsell=0;
39 |         for(i=0;i<n;++i){
40 |             if(rec[i].isvalid==false)continue;
41 |             if(rec[i].opt=="buy"&&rec[i].price>=p){
42 |                 sumbuy+=rec[i].amount;
43 |             }
44 |             else if(rec[i].opt=="sell"&&rec[i].price<=p){
45 |                 sumsell+=rec[i].amount;
46 |             }
47 |         }
48 |         long long sum=min(sumsell,sumbuy);//成交量
49 |         if(sum>=maxsum){
50 |             maxsum=sum;
51 |             ansp=p;
52 |         }
53 |     }
54 |     printf("%.2lf %lld\n",ansp,maxsum);
55 |     return 0;
56 | }
57 | 


--------------------------------------------------------------------------------
/201412-4 最优灌溉 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | #define INF 0x7fffffff
 4 | using namespace std;
 5 | int prim(vector<vector<int> > &v,int u)
 6 | {
 7 |     int n=v.size()-1,minv,sum=0;
 8 |     vector<int> cost=v[u];
 9 |     vector<bool> vis(n+1,false);
10 |     vis[u]=true;
11 |     for(int i=1;i<n;++i)
12 |     {
13 |         int val=INF;
14 |         for(int k=1;k<=n;++k) if(!vis[k]&&cost[k]<val) val=cost[minv=k];
15 |         sum+=val;
16 |         vis[minv]=true;
17 |         for(int i=1;i<=n;++i) if(!vis[i]&&cost[i]>v[minv][i]) cost[i]=v[minv][i];
18 |     }
19 |     return sum;
20 | 
21 | }
22 | int main()
23 | {
24 |     int n,m;
25 |     cin>>n>>m;
26 |     vector<vector<int> > adj(n+1,vector<int>(n+1,INF));
27 |     for(int i=0;i<m;++i)
28 |     {
29 |         int s,e,w;
30 |         cin>>s>>e>>w;
31 |         adj[s][e]=w;
32 |         adj[e][s]=w;
33 |     }
34 |     cout<<prim(adj,1);
35 |     return 0;
36 | }
37 | 


--------------------------------------------------------------------------------
/201503-1 图像旋转 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int a[1024][1024];
 4 | int main()
 5 | {
 6 |     int n,m;
 7 |     cin>>n>>m;
 8 |     for(int i=0;i<n;++i){
 9 |         for(int j=0;j<m;++j){
10 |             cin>>a[i][j];
11 |         }
12 |     }
13 |     for(int j=m-1;j>=0;--j){
14 |         for(int i=0;i<n;++i){
15 |             cout<<a[i][j]<<" ";
16 |         }
17 |         cout<<endl;
18 |     }
19 |     return 0;
20 | }
21 | 


--------------------------------------------------------------------------------
/201503-2 数字排序 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int n,cnt[1024];
 4 | struct node
 5 | {
 6 |     int idx,w;
 7 |     node(int a,int b):idx(a),w(b){}
 8 | };
 9 | vector<node> v;
10 | bool cmp(const node &a,const node &b)
11 | {
12 |     return a.w==b.w?a.idx<b.idx:a.w>b.w;
13 | }
14 | int main()
15 | {
16 |     cin>>n;
17 |     for(int i=0;i<n;++i)
18 |     {
19 |         int x;
20 |         cin>>x;
21 |         cnt[x]++;
22 |     }
23 |     for(int i=0;i<=1000;++i)
24 |     {
25 |         if(cnt[i])
26 |             v.push_back(node(i,cnt[i]));
27 |     }
28 |     sort(v.begin(),v.end(),cmp);
29 |     for(size_t i=0;i<v.size();++i)
30 |     {
31 |         cout<<v[i].idx<<" "<<v[i].w<<endl;
32 |     }
33 |     return 0;
34 | }
35 | 


--------------------------------------------------------------------------------
/201503-3 节日 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int month[]={-1,31,28,31,30,31,30,31,31,30,31,30,31};
 4 | bool isleapyear(int y)
 5 | {
 6 |     return (y%4==0&&y%100)||(y%400==0);
 7 | }
 8 | int cptdays(int s,int e,int m)
 9 | {
10 |     int sumday=0;
11 |     while(s<e){
12 |         sumday+=isleapyear(s++)?366:365;
13 |     }
14 |     if(isleapyear(e))month[2]=29;
15 |     for(int i=1;i<m;++i){
16 |         sumday+=month[i];
17 |     }
18 |     return sumday;
19 | }
20 | int thisdaybyweek(int w,int c,int b)
21 | {
22 |     int day=1;
23 |     while(w!=c){
24 |         ++day;
25 |         ++w;
26 |         if(w==8)w=1;
27 |     }
28 |     return day+(b-1)*7;
29 | }
30 | int main()
31 | {
32 |     int a,b,c,y1,y2;
33 |     scanf("%d %d %d %d %d",&a,&b,&c,&y1,&y2);
34 |     while(y1<=y2){
35 |         int w=(cptdays(1850,y1,a)+2)%7;//a月1日星期几
36 |         if(w==0)w=7;
37 |         //printf("week : %d\n",w);
38 |         int day=thisdaybyweek(w,c,b);
39 |         if(day>month[a])printf("none\n");
40 |         else printf("%d/%02d/%02d\n",y1,a,day);
41 |         month[2]=28;
42 |         ++y1;
43 |     }
44 |     return 0;
45 | }
46 | 


--------------------------------------------------------------------------------
/201503-4 网络延时 ccf.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | vector<int> v[20018];
 4 | int n,m;
 5 | void dfs(int u,int depth,int &maxdepth,int &maxdepvertex,bool visit[])
 6 | {
 7 | 	visit[u]=1;
 8 | 	if(depth>maxdepth)
 9 | 	{
10 | 		maxdepth=depth;
11 | 		maxdepvertex=u;
12 | 	}
13 | 	for(size_t i=0;i<v[u].size();++i)
14 | 	{
15 | 		int w=v[u][i];//u的邻接点
16 | 		if(!visit[w]) dfs(w,depth+1,maxdepth,maxdepvertex,visit);
17 | 	}
18 | }
19 | int main()
20 | {
21 | 	scanf("%d %d",&n,&m);
22 | 	for(int i=2;i<=n;++i)
23 | 	{
24 | 		int x;
25 | 		scanf("%d",&x);
26 | 		v[x].push_back(i);
27 | 		v[i].push_back(x);
28 | 	}
29 | 	for(int i=1;i<=m;++i)
30 | 	{
31 | 		int x;
32 | 		scanf("%d",&x);
33 | 		v[x].push_back(10000+i);
34 | 		v[10000+i].push_back(x);
35 | 	}
36 | 	bool v1[20018]={0},v2[20018]={0};//visit数组
37 | 	int maxdepth=-1,maxdepvertex=-1;
38 | 	dfs(1,0,maxdepth,maxdepvertex,v1);
39 | 	dfs(maxdepvertex,0,maxdepth,maxdepvertex,v2);
40 | 	printf("%d\n",maxdepth);
41 | 	return 0;
42 | }
43 | 


--------------------------------------------------------------------------------
/201509-1 数列分段 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int a[1024][1024];
 4 | int main()
 5 | {
 6 |     int n,cnt=1,pre,cur;
 7 |     cin>>n>>pre;
 8 |     n--;
 9 |     while(n--)
10 |     {
11 |         cin>>cur;
12 |         if(pre==cur) continue;
13 |         else 
14 |         {
15 |             pre=cur;
16 |             ++cnt;
17 |         }
18 |     }
19 |     cout<<cnt;
20 |     return 0;
21 | }
22 | 


--------------------------------------------------------------------------------
/201509-2 日期计算 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int month[]={-1,31,28,31,30,31,30,31,31,30,31,30,31};
 4 | bool isleapyear(int y)
 5 | {
 6 |     return (y%4==0&&y%100)||(y%400==0);
 7 | }
 8 | int main()
 9 | {
10 |     int y,d;
11 |     cin>>y>>d;
12 |     if(isleapyear(y)) month[2]+=1;
13 |     int m=1,sumday=0;
14 |     while(m<=12&&sumday<d)
15 |     {
16 |         sumday+=month[m++];
17 |     }
18 |     m--;
19 |     cout<<m<<endl<<d-sumday+month[m];
20 |     return 0;
21 | }
22 | 


--------------------------------------------------------------------------------
/201509-3 模板生成系统 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int n,m;
 6 |     string instr,outstr;
 7 |     map<string,string> mv;
 8 |     cin>>n>>m;
 9 |     cin.get();
10 |     while(n--){
11 |         string line;
12 |         getline(cin,line);
13 |         instr+=line+'\n';
14 |     }
15 |     while(m--){
16 |         string var,x;
17 |         cin>>var;
18 |         cin.get();
19 |         getline(cin,x);
20 |         mv[var]=x.substr(1,x.size()-2);
21 |     }
22 |     size_t pos,nextpos;
23 |     while((pos=instr.find("{{ "))!=string::npos){
24 |         nextpos=instr.find(" }}")+3;
25 |         string var(instr.begin()+pos+3,instr.begin()+nextpos-3);
26 |         outstr+=instr.substr(0,pos);
27 |         instr=instr.substr(nextpos);
28 |         string val=mv.count(var)?mv[var]:"";
29 |         outstr+=val;
30 |     }
31 |     outstr+=instr;
32 |     cout<<outstr;
33 |     return 0;
34 | }
35 | 
36 | 


--------------------------------------------------------------------------------
/201509-4 高速公路 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | #include <stack>
 4 | using namespace std;
 5 | vector<int> v[10001];
 6 | stack<int> stk;
 7 | int DFN[10001],LOW[10001];
 8 | int index,ans;
 9 | bool vis[10001];
10 | void TarJan(int u)
11 | {
12 |     DFN[u]=LOW[u]=++index;
13 |     stk.push(u);
14 |     vis[u]=true;
15 |     for(unsigned int i=0;i<v[u].size();++i)
16 |     {
17 |         int w=v[u][i];
18 |         if(!DFN[w])
19 |         {
20 |             TarJan(w);
21 |             LOW[u]=min(LOW[u],LOW[w]);
22 |         }
23 |         else if(vis[w]) LOW[u]=min(LOW[u],DFN[w]);
24 |     }
25 |     if(DFN[u]==LOW[u])
26 |     {
27 |         int s,cnt=0;
28 |         do{
29 |             s=stk.top();
30 |             stk.pop();
31 |             vis[s]=false;
32 |             ++cnt;
33 |         }while(u!=s);
34 |         if(cnt>1) ans+=cnt*(cnt-1)/2;
35 |     }
36 | } 
37 | int main()
38 | {
39 |     int n,m;
40 |     cin>>n>>m;
41 |     for(int i=0;i<m;++i)
42 |     {
43 |         int s,e;
44 |         cin>>s>>e;
45 |         v[s].push_back(e);
46 |     }
47 |     for(int i=1;i<=n;++i)
48 |     {
49 |         if(!DFN[i]) TarJan(i);
50 |     }
51 |     cout<<ans;
52 |     return 0;
53 | }
54 | 


--------------------------------------------------------------------------------
/201512-1 数位之和 ccf.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 | 	char x;
 6 | 	int sum=0;
 7 | 	while((x=getchar())!='\n')
 8 | 		sum+=x-'0';
 9 | 	cout<<sum;
10 | 	return 0;
11 | }
12 | 


--------------------------------------------------------------------------------
/201512-2 消除类游戏 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int n,m,a[32][32],b[32][32];
 4 | int main()
 5 | {
 6 |     cin>>n>>m;
 7 |     for(int i=0;i<n;++i){
 8 |         for(int j=0;j<m;++j)
 9 |             cin>>a[i][j];
10 |     }
11 |     for(int i=0;i<n;++i){
12 |         for(int j=0;j<m;++j){
13 |             int k=j+1;
14 |             while(k<m&&a[i][k]==a[i][k-1])++k;
15 |             if(k-j<3){
16 |                 j=k-1;
17 |             }
18 |             else{
19 |                 while(j<k)b[i][j++]=1;
20 |                 --j;
21 |             }
22 |         }
23 |     }
24 |     for(int j=0;j<m;++j){
25 |         for(int i=0;i<n;++i){
26 |             int k=i+1;
27 |             while(k<n&&a[k][j]==a[k-1][j])++k;
28 |             if(k-i<3){
29 |                 i=k-1;
30 |             }
31 |             else{
32 |                 while(i<k)b[i++][j]=1;
33 |                 --i;
34 |             }
35 |         }
36 |     }
37 |     for(int i=0;i<n;++i){
38 |         for(int j=0;j<m;++j){
39 |             if(b[i][j]==0)
40 |                 cout<<a[i][j]<<" ";
41 |             else cout<<0<<" ";
42 |         }
43 |         cout<<endl;
44 |     }
45 |     return 0;
46 | }
47 | 


--------------------------------------------------------------------------------
/201512-3 画图 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | using namespace std;
 3 | char a[128][128];
 4 | int n,m,q;
 5 | void init()
 6 | {
 7 |     for(int i=0;i<m;++i){
 8 |         for(int j=0;j<n;++j){
 9 |             a[i][j]='.';
10 |         }
11 |     }
12 | }
13 | bool isrange(int x,int y)
14 | {
15 |     return x>=0&&y>=0&&x<n&&y<m;
16 | }
17 | bool isline(char c)
18 | {
19 |     return c=='-'||c=='|'||c=='+';
20 | }
21 | void paintline(int x1,int y1,int x2,int y2)
22 | {
23 |     if(x1==x2){
24 |         if(y1>y2)swap(y1,y2);
25 |         int y=y1;
26 |         while(y<=y2){
27 |             if(isline(a[y][x1])&&a[y][x1]!='|')a[y][x1]='+';
28 |             else a[y][x1]='|';
29 |             ++y;
30 |         }
31 |     }
32 |     else{//y1==y2
33 |         if(x1>x2)swap(x1,x2);
34 |         int x=x1;
35 |         while(x<=x2){
36 |             if(isline(a[y1][x])&&a[y1][x]!='-')a[y1][x]='+';
37 |             else a[y1][x]='-';
38 |             ++x;
39 |         }
40 |     }
41 | }
42 | void fillblank(int x,int y,char c,int visit[][128])
43 | {
44 |     if(visit[y][x]||!isrange(x,y)||isline(a[y][x]))return;
45 |     a[y][x]=c;
46 |     visit[y][x]=1;
47 |     fillblank(x-1,y,c,visit);
48 |     fillblank(x+1,y,c,visit);
49 |     fillblank(x,y-1,c,visit);
50 |     fillblank(x,y+1,c,visit);
51 | }
52 | int main()
53 | {
54 |     cin>>n>>m>>q;
55 |     init();
56 |     while(q--){
57 |         int opt;
58 |         cin>>opt;
59 |         if(opt==0){
60 |             int x1,y1,x2,y2;
61 |             cin>>x1>>y1>>x2>>y2;
62 |             paintline(x1,y1,x2,y2);
63 |         }
64 |         else{
65 |             int x,y;
66 |             char c;
67 |             cin>>x>>y>>c;
68 |             int visit[128][128]={0};
69 |             fillblank(x,y,c,visit);
70 |         }
71 |     }
72 |     for(int i=m-1;i>=0;--i){
73 |         for(int j=0;j<n;++j){
74 |             cout<<a[i][j];
75 |         }
76 |         cout<<endl;
77 |     }
78 |     return 0;
79 | }
80 | 


--------------------------------------------------------------------------------
/201512-4 送货 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | #include <algorithm>
 4 | #include <stack>
 5 | using namespace std;
 6 | bool arcvis[10001][10001];
 7 | int de[10001];
 8 | void dis(vector<int> v)
 9 | {
10 |     int i=v.size()-1;
11 |     while(i>=0) cout<<v[i--]<<" ";
12 | }
13 | int main()
14 | {
15 |     int n,m,odd=0;
16 |     vector<int> ans,v[10001];
17 |     stack<int> stk;
18 |     cin>>n>>m;
19 |     for(int i=0;i<m;++i)
20 |     {
21 |         int u,w;
22 |         cin>>u>>w;
23 |         v[u].push_back(w);
24 |         v[w].push_back(u);
25 |         de[u]++;de[w]++;
26 |     }
27 |     for(int i=1;i<=n;++i)
28 |     {
29 |         sort(v[i].begin(),v[i].end());
30 |         if(de[i]&1) odd++;
31 |     }
32 |     stk.push(1);
33 |     while(!stk.empty())
34 |     {
35 |         int u=stk.top();
36 |         bool flag=false;
37 |         for(unsigned int i=0;i<v[u].size();++i)
38 |         {
39 |             int w=v[u][i];
40 |             if(!arcvis[w][u])
41 |             {
42 |                 flag=true;
43 |                 stk.push(w);
44 |                 arcvis[u][w]=true;
45 |                 arcvis[w][u]=true;
46 |                 break;
47 |             }
48 |         }
49 |         if(!flag)
50 |         {
51 |             ans.push_back(u);
52 |             stk.pop();
53 |         }
54 |     }
55 |     if(ans.size()==m+1&&(odd==0||(odd==2&&de[1]&1))) dis(ans);
56 |     else cout<<-1;
57 |     return 0;
58 | }
59 | 


--------------------------------------------------------------------------------
/201604-1 折点计数 ccf.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int n,cnt=0;
 6 |     vector<int> v;
 7 |     scanf("%d",&n);
 8 |     v.resize(n);
 9 |     for(int i=0;i<n;++i)
10 |         cin>>v[i];
11 |     for(int i=1;i+1<n;++i)
12 |     {
13 |         if((v[i]>v[i-1]&&v[i]>v[i+1])||(v[i]<v[i-1]&&v[i]<v[i+1]))
14 |             ++cnt;
15 |     }
16 |     cout<<cnt<<endl;
17 |     return 0;
18 | }
19 | 


--------------------------------------------------------------------------------
/201604-2 俄罗斯方块 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int mat[16][11];
 4 | int v[5][5],L,d;
 5 | bool judge(int r,int p)
 6 | {
 7 |     for(int i=d;i>=1&&r>=p;--i)
 8 |     {
 9 |         for(int j=1;j<=4;++j)
10 |             if(v[i][j]&&mat[r][L+j-1])
11 |                 return false;
12 |         --r;
13 |     }
14 |     return true;
15 | }
16 | void putv()
17 | {
18 |     int r=1;
19 |     while(r<=15)
20 |     {
21 |         if(judge(r,max(r-3,1)))++r;
22 |         else break;
23 |     }
24 |     --r;
25 |     for(int i=d;i>=1&&r>=max(r-3,1);--i)
26 |     {
27 |         for(int j=1;j<=4;++j)
28 |             if(v[i][j])mat[r][L+j-1]=1;
29 |         --r;
30 |     }
31 | }
32 | void disp()
33 | {
34 |     for(int i=1;i<=15;++i)
35 |     {
36 |         for(int j=1;j<=10;++j)
37 |             printf("%d ",mat[i][j]);
38 |         printf("\n");
39 |     }
40 | }
41 | int main()
42 | {
43 |     for(int i=1;i<=15;++i)
44 |     {
45 |         for(int j=1;j<=10;++j)
46 |             cin>>mat[i][j];
47 |     }
48 |     for(int i=1;i<=4;++i)
49 |     {
50 |         for(int j=1;j<=4;++j)
51 |         {
52 |             cin>>v[i][j];
53 |             if(v[i][j]==1) d=i;
54 |         }
55 |     }
56 |     cin>>L;
57 |     putv();
58 |     disp();
59 |     return 0;
60 | }
61 | 


--------------------------------------------------------------------------------
/201604-4 游戏 ccf.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | struct point{
 4 | 	int x,y,time;
 5 | 	point(int xx,int yy,int tt):x(xx),y(yy),time(tt){}
 6 | };
 7 | int unsafe[128][128][2],visit[128][128][312];
 8 | int n,m,t;
 9 | int dx[]={0,1,0,-1};
10 | int dy[]={1,0,-1,0};
11 | bool islegal(int x,int y)
12 | {
13 | 	return x>=1&&y>=1&&x<=n&&y<=m;
14 | }
15 | bool issafe(int x,int y,int time)
16 | {
17 | 	return unsafe[x][y][0]>time||unsafe[x][y][1]<time;
18 | }
19 | int main()
20 | {
21 | 	// freopen("1.txt","r",stdin);
22 | 	scanf("%d %d %d",&n,&m,&t);
23 | 	for(int i=0;i<t;++i){
24 | 		int x,y,s,e;
25 | 		scanf("%d %d %d %d",&x,&y,&s,&e);
26 | 		unsafe[x][y][0]=s;
27 | 		unsafe[x][y][1]=e;
28 | 	}
29 | 	point s(1,1,0);
30 | 	queue<point> q;
31 | 	q.push(s);
32 | 	while(!q.empty()){
33 | 		point p=q.front();
34 | 		q.pop();
35 | 		if(p.x==n&&p.y==m){
36 | 			printf("%d\n",p.time);
37 | 			return 0;
38 | 		}
39 | 		int thistime=p.time+1;
40 | 		for(int i=0;i<4;++i){
41 | 			int xx=p.x+dx[i],yy=p.y+dy[i];
42 | 			if(islegal(xx,yy)&&issafe(xx,yy,thistime)&&!visit[xx][yy][thistime]){
43 | 				//printf("(%d %d %d)\n",xx,yy,thistime);
44 | 				point nextp(xx,yy,thistime);
45 | 				q.push(nextp);
46 | 				visit[xx][yy][thistime]=1;
47 | 			}
48 | 		}
49 | 	}
50 | 	return 0;
51 | }
52 | 


--------------------------------------------------------------------------------
/201609-1 最大波动 ccf.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 | 	int n,maxval=0;
 6 | 	vector<int> v;
 7 | 	scanf("%d",&n);
 8 | 	for(int i=0;i<n;++i)
 9 | 	{
10 | 		int x;
11 | 		scanf("%d",&x);
12 | 		v.push_back(x);
13 | 	}
14 | 	for(int i=1;i<n;++i)
15 | 		maxval=max(maxval,abs(v[i]-v[i-1]));
16 | 	cout<<maxval<<endl;
17 | 	return 0;
18 | }
19 | 


--------------------------------------------------------------------------------
/201609-2 火车购票 ccf.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 | 	int n;
 6 | 	scanf("%d",&n);
 7 | 	vector<int> v(20,5);
 8 | 	for(int i=0;i<n;++i)
 9 | 	{
10 | 		int x;
11 | 		scanf("%d",&x);
12 | 		for(int r=0;r<20&&x>0;++r)
13 | 		{
14 | 			if(v[r]>=x)//当前行空余座位大于需求x
15 | 			{
16 | 				int seat=r*5+5-v[r]+1;//开始空闲座位编号
17 | 				v[r]-=x;//x个订购，更新空余座位
18 | 				while(x--)
19 | 				{
20 | 					cout<<seat++;
21 | 					if(x>0) cout<<" ";
22 | 					else cout<<endl;
23 | 				}
24 | 			}
25 | 		}
26 | 		if(x>0)//没有连续座位
27 | 		{
28 | 			for(int r=0;r<20&&x>0;++r)
29 | 			{
30 | 				while(v[r]>0&&x>0)
31 | 				{
32 | 					int seat=r*5+5-v[r]+1;
33 | 					cout<<seat++;
34 | 					--v[r];
35 | 					--x;
36 | 					if(x>0)cout<<" ";
37 | 					else cout<<endl;
38 | 				}
39 | 			}
40 | 		}
41 | 	}
42 | 	return 0;
43 | }
44 | 


--------------------------------------------------------------------------------
/201609-3 炉石传说 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | struct role
 4 | {
 5 |     int attack,health;
 6 |     role(int ak,int ht):attack(ak),health(ht){}
 7 | };
 8 | vector<role> va,vb;
 9 | int n,turn=0;
10 | void dis(vector<role> &v)
11 | {
12 |     cout<<v[0].health<<endl;
13 |     cout<<v.size()-1;
14 |     for(size_t i=1;i<v.size();++i)
15 |     {
16 |         cout<<" "<<v[i].health;
17 |     }
18 |     cout<<endl;
19 | }
20 | int main()
21 | {
22 |     va.push_back(role(0,30));
23 |     vb.push_back(role(0,30));
24 |     cin>>n;
25 |     for(int i=0;i<n;++i)
26 |     {
27 |         string action;
28 |         cin>>action;
29 |         if(action=="summon")
30 |         {
31 |             int pos,ak,ht;
32 |             cin>>pos>>ak>>ht;
33 |             if(turn==0)
34 |                 va.insert(va.begin()+pos,role(ak,ht));
35 |             else
36 |                 vb.insert(vb.begin()+pos,role(ak,ht));
37 |         }
38 |         else if(action=="end")
39 |             turn=(turn+1)%2;
40 |         else if(action=="attack")
41 |         {
42 |             int i,j;
43 |             cin>>i>>j;
44 |             if(turn==0)
45 |             {
46 |                 va[i].health-=vb[j].attack;
47 |                 vb[j].health-=va[i].attack;
48 |                 if(va[i].health<=0&&i)
49 |                 {
50 |                     va.erase(va.begin()+i);
51 |                 }
52 |                 if(vb[j].health<=0&&j)
53 |                 {
54 |                     vb.erase(vb.begin()+j);
55 |                 }
56 |             }
57 |             else
58 |             {
59 |                 vb[i].health-=va[j].attack;
60 |                 va[j].health-=vb[i].attack;
61 |                 if(va[j].health<=0&&j)
62 |                 {
63 |                     va.erase(va.begin()+j);
64 |                 }
65 |                 if(vb[i].health<=0&&i)
66 |                 {
67 |                     vb.erase(vb.begin()+i);
68 |                 }
69 |             }
70 |         }
71 |         if(va[0].health<=0||vb[0].health<=0)
72 |         {
73 |             break;
74 |         }
75 |     }
76 |     if(va[0].health<=0&&vb[0].health>0)
77 |         cout<<-1<<endl;
78 |     else if(va[0].health>0&&vb[0].health<=0)
79 |         cout<<1<<endl;
80 |     else cout<<0<<endl;
81 |     dis(va);
82 |     dis(vb);
83 |     return 0;
84 | }
85 | 


--------------------------------------------------------------------------------
/201609-4 交通规划 ccf.cpp:
--------------------------------------------------------------------------------
 1 | /*数据量过大，需采用堆优化的dijkstra算法*/
 2 | #include <bits/stdc++.h>
 3 | using namespace std;
 4 | const int Inf=0x7fffffff;
 5 | int n,m;
 6 | struct edge
 7 | {
 8 | 	int v;
 9 | 	int cost;
10 | 	edge(int x,int c):v(x),cost(c){}
11 | };
12 | struct cmp
13 | {
14 | 	bool operator()(edge &a,edge &b)
15 | 	{
16 | 		return a.cost>b.cost;
17 | 	}
18 | };
19 | vector<edge> vg[10000];
20 | int main()
21 | {
22 | 	scanf("%d %d",&n,&m);
23 | 	for(int i=0;i<m;++i)
24 | 	{
25 | 		int x,y,w;
26 | 		scanf("%d %d %d",&x,&y,&w);
27 | 		--x,--y;
28 | 		vg[x].push_back(edge(y,w));
29 | 		vg[y].push_back(edge(x,w));
30 | 	}
31 | 	//dijkstra
32 | 	priority_queue<edge,vector<edge>,cmp> pq;
33 | 	vector<int> dist(n,Inf);
34 | 	vector<int> cost(n,Inf);
35 | 	vector<bool> visit(n,0);
36 | 	pq.push(edge(0,0));
37 | 	dist[0]=cost[0]=0;
38 | 	while(!pq.empty())
39 | 	{
40 | 		edge t=pq.top();//最短路径（花费）边
41 | 		pq.pop();
42 | 		visit[t.v]=1;//访问该节点
43 | 		for(size_t i=0;i<vg[t.v].size();++i)
44 | 		{
45 | 			edge e=vg[t.v][i];//该节点的所有邻接边
46 | 			if(visit[e.v])continue;//另外一端节点访问过了，跳过
47 | 			if(dist[e.v]>dist[t.v]+e.cost)//更新最短路径
48 | 			{
49 | 				dist[e.v]=dist[t.v]+e.cost;
50 | 				cost[e.v]=e.cost;
51 | 				pq.push(edge(e.v,dist[e.v]));//新的更新边
52 | 			}
53 | 			else if(dist[e.v]==dist[t.v]+e.cost)
54 | 			{
55 | 				cost[e.v]=min(cost[e.v],e.cost);
56 | 			}
57 | 		}
58 | 	}
59 | 	int sum=0;
60 | 	for(int i=0;i<n;++i)
61 | 		sum+=cost[i];
62 | 	printf("%d\n",sum);
63 | 	return 0;
64 | }
65 | 


--------------------------------------------------------------------------------
/201612-1 中间数 ccf.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 | 	int n;
 6 | 	vector<int> v;
 7 | 	scanf("%d",&n);
 8 | 	for(int i=0;i<n;++i)
 9 | 	{
10 | 		int x;
11 | 		scanf("%d",&x);
12 | 		v.push_back(x);
13 | 	}
14 | 	sort(v.begin(),v.end());
15 | 	int j=v.size()/2,i=(v.size()%2==0)?j-1:j;
16 | 	int e=v[j];
17 | 	while(i>=0&&j<n&&v[i]==v[j]&&v[i]==e)--i,++j;
18 | 	if(i>=0&&(v[i]==e||v[j]==e))
19 | 		cout<<-1;
20 | 	else cout<<e;
21 | 	return 0;
22 | }
23 | 


--------------------------------------------------------------------------------
/201612-2 工资计算 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | double rate[]={0,0.03,0.1,0.2,0.25,0.3,0.35,0.45};
 3 | int v[]={3500,1500,3000,4500,26000,20000,25000};
 4 | int u[]={3500,1500,3000,4500,26000,20000,25000};
 5 | void cpt()
 6 | {
 7 |     for(int i=1;i<7;++i)
 8 |     {
 9 |         u[i]+=u[i-1];
10 |         v[i]=v[i-1]+v[i]*(1-rate[i]);
11 |     }
12 | }
13 | int main() 
14 | {
15 |     int t,i=0;
16 |     scanf("%d",&t);
17 |     if(t<=3500)
18 |     {
19 |         printf("%d\n",t);
20 |         return 0;
21 |     }
22 |     cpt();
23 |     while(v[i]<=t&&i<7)++i;
24 |     --i;
25 |     int s=u[i]+(t-v[i])/(1-rate[i+1]);
26 |     printf("%d\n",s);
27 |     return 0;
28 | }
29 | 


--------------------------------------------------------------------------------
/201612-3 权限查询 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | map<string,int> pri;
 4 | map<string,map<string,int> > rol;
 5 | map<string,map<string,int> > usr;
 6 | void find(string u,string x,int lev)
 7 | {
 8 |     if(usr.count(u)>0&&usr[u].count(x)>0)
 9 |     {
10 |         if(lev==-1)
11 |         {
12 |             if(usr[u][x]>-1) cout<<usr[u][x]<<endl;
13 |             else cout<<"true\n";
14 |         }
15 |         else
16 |         {
17 |             if(usr[u][x]>=lev) cout<<"true\n";
18 |             else cout<<"false\n";
19 |         }
20 |     }
21 |     else cout<<"false\n";
22 | }
23 | int main() 
24 | {
25 |     int n;
26 |     cin>>n;//p
27 |     while(n--)
28 |     {
29 |         string x;
30 |         cin>>x;
31 |         size_t pos=x.find(":");
32 |         if(pos==string::npos) pri[x]=-1;
33 |         else
34 |         {
35 |             int lev=x[pos+1]-'0';
36 |             x=x.substr(0,pos);
37 |             pri[x]=max(pri[x],lev);
38 |         }
39 |     }
40 |     cin>>n;//r
41 |     while(n--)
42 |     {
43 |         string role;
44 |         int k;
45 |         cin>>role>>k;
46 |         while(k--)
47 |         {
48 |             string x;
49 |             cin>>x;
50 |             size_t pos=x.find(":");
51 |             if(pos==string::npos) rol[role][x]=-1;
52 |             else
53 |             {
54 |                 int lev=x[pos+1]-'0';
55 |                 x=x.substr(0,pos);
56 |                 rol[role][x]=max(rol[role][x],lev);
57 |             }
58 |         }
59 |     }
60 |     cin>>n;//u
61 |     while(n--)
62 |     {
63 |         string u;
64 |         int k;
65 |         cin>>u>>k;
66 |         while(k--)
67 |         {
68 |             string x;
69 |             cin>>x;
70 |             map<string,int>::iterator it=rol[x].begin();
71 |             while(it!=rol[x].end())
72 |             {
73 |                 if(usr[u].count(it->first)>0)
74 |                     usr[u][it->first]=max(usr[u][it->first],it->second);
75 |                 else
76 |                     usr[u][it->first]=it->second;
77 |                 ++it;
78 |             }
79 |         }
80 |     }
81 |     cin>>n;//q
82 |     while(n--)
83 |     {
84 |         string u,x;
85 |         cin>>u>>x;
86 |         size_t pos=x.find(":");
87 |         if(pos==string::npos) find(u,x,-1);
88 |         else find(u,x.substr(0,pos),x[pos+1]-'0');
89 |     }
90 |     return 0;
91 | }
92 | 


--------------------------------------------------------------------------------
/201612-4 压缩编码 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int a[1024],sum[1024],dp[1024][1024];
 4 | int main()
 5 | {
 6 |     int n;
 7 |     scanf("%d",&n);
 8 |     for(int i=1;i<=n;++i)
 9 |     {
10 |         scanf("%d",&a[i]);
11 |         sum[i]=sum[i-1]+a[i];
12 |         for(int j=1;j<=n;++j){
13 |             i==j?dp[i][j]=0:dp[i][j]=0x7fffffff;
14 |         }
15 |     }
16 |     for(int w=2;w<=n;++w)
17 |     {
18 |         for(int i=1;i+w-1<=n;++i)
19 |         {
20 |             int j=i+w-1,s=sum[j]-sum[i-1];
21 |             for(int k=i;k<j;++k)
22 |                 dp[i][j]=min(dp[i][j],dp[i][k]+dp[k+1][j]+s);
23 |         }
24 |     }
25 |     printf("%d\n",dp[1][n]);
26 |     return 0;
27 | }
28 | 


--------------------------------------------------------------------------------
/201703-1 分蛋糕 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int n,k,s=0,i=0,w,cnt=0;
 6 |     cin>>n>>k;
 7 |     while(i<n)
 8 |     {
 9 |         cin>>w;
10 |         ++i;
11 |         s=w;
12 |         while(i<n&&s<k)
13 |         {
14 |             cin>>w;
15 |             s+=w;
16 |             ++i;
17 |         }
18 |         ++cnt;
19 |     }
20 |     cout<<cnt;
21 |     return 0;
22 | }
23 | 


--------------------------------------------------------------------------------
/201703-2 学生排队 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int n,m;
 4 | int mpos[1024],v[1024];
 5 | void move(int pos,int len,int stp)
 6 | {
 7 |     int temp=v[pos];
 8 |     while(len)
 9 |     {
10 |         v[pos]=v[pos+stp];
11 |         mpos[v[pos]]=pos;
12 |         pos+=stp;
13 |         --len;
14 |     }
15 |     mpos[temp]=pos;
16 |     v[pos]=temp;
17 | }
18 | int main()
19 | {
20 |     cin>>n>>m;
21 |     for(int i=1;i<=n;++i)
22 |     {
23 |         mpos[i]=i;
24 |         v[i]=i;
25 |     }
26 |     for(int i=0;i<m;++i)
27 |     {
28 |         int id,val;
29 |         cin>>id>>val;
30 |         int pos=mpos[id];
31 |         val<0?move(pos,-val,-1):move(pos,val,1);
32 |     }
33 |     for(int i=1;i<=n;++i)
34 |         cout<<v[i]<<" ";
35 |     return 0;
36 | }
37 | 


--------------------------------------------------------------------------------
/201703-3 Markdown ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     //freopen("3.txt","r",stdin);
 6 |     string line,text;
 7 |     bool x=false;
 8 |     getline(cin,line);
 9 |     while(true)
10 |     {
11 |         if(line.size()>0)
12 |         {
13 |             text+=line+"\n";
14 |         }
15 |         else if(line.size()==0&&text.size()>0)
16 |         {
17 |             size_t pos=text.find("_");
18 |             while(pos!=string::npos)
19 |             {
20 |                 text.replace(pos,1,"<em>");
21 |                 size_t nxp=text.find("_",pos);
22 |                 text.replace(nxp,1,"</em>");
23 |                 pos=text.find("_",nxp);
24 |             }
25 |             pos=text.find("[");
26 |             while(pos!=string::npos)
27 |             {
28 |                 size_t nxp=text.find("]",pos);
29 |                 size_t lp=text.find("(",nxp);
30 |                 size_t rp=text.find(")",lp);
31 |                 string tt=text.substr(pos+1,nxp-pos-1);
32 |                 string lk=text.substr(lp+1,rp-lp-1);
33 |                 text.replace(text.begin()+pos,text.begin()+rp+1,"<a href=\""+lk+"\">"+tt+"</a>");
34 |                 pos=text.find("[",rp);
35 |             }
36 |             if(text[0]=='#')
37 |             {
38 |                 int i=0;
39 |                 while(text[i]=='#') ++i;
40 |                 text=text.substr(i+1);
41 |                 text="<h"+string(1,'0'+i)+">"+text;
42 |                 text.insert(text.size()-1,"</h"+string(1,'0'+i)+">");
43 |             }
44 |             else if(text[0]=='*')
45 |             {
46 |                 text.insert(0,"<ul>\n");
47 |                 text.insert(text.size(),"</ul>\n");
48 |                 size_t pos=text.find("*");
49 |                 while(pos!=string::npos)
50 |                 {
51 |                     size_t nxp=text.find("\n",pos);
52 |                     text.insert(nxp,"</li>");
53 |                     text.replace(pos,2,"<li>");
54 |                     pos=text.find("*",nxp);
55 |                 }
56 |             }
57 |             else
58 |             {
59 |                 text="<p>"+text;
60 |                 text.insert(text.size()-1,"</p>");
61 |             }
62 |             cout<<text;
63 |             text="";
64 |         }
65 |         line="";
66 |         if(x) break;
67 |         if(!getline(cin,line))
68 |         {
69 |             x=true;
70 |             line="";
71 |         }
72 |     }
73 |     return 0;
74 | }
75 | 


--------------------------------------------------------------------------------
/201703-4 地铁修建 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <iostream>
 2 | #include <vector>
 3 | #include <algorithm>
 4 | #define Inf 0x7fffffff
 5 | using namespace std;
 6 | struct node
 7 | {
 8 |     int u,v;
 9 |     int w;
10 |     node(int a,int b,int x):u(a),v(b),w(x){}
11 |     bool operator <(const node &p)const
12 |     {
13 |         return w<p.w;
14 |     }
15 | };
16 | vector<node> edge;
17 | int vn,an;
18 | int pa[100001];
19 | int find(int x)
20 | {
21 |     return x==pa[x]?x:pa[x]=find(pa[x]);
22 | }
23 | int kruskal()
24 | {
25 |     for(int i=1;i<=vn;++i) pa[i]=i;
26 |     for(int i=0;i<an;++i)
27 |     {
28 |         int x=find(edge[i].u),y=find(edge[i].v);
29 |         if(x!=y) pa[x]=y;
30 |         if(find(1)==find(vn))  return edge[i].w;
31 |     }
32 |     return -1;
33 | }
34 | int main()
35 | {
36 |     cin>>vn>>an;
37 |     for(int i=0;i<an;++i)
38 |     {
39 |         int a,b,x;
40 |         cin>>a>>b>>x;
41 |         edge.push_back(node(a,b,x));
42 |     }
43 |     sort(edge.begin(),edge.end());
44 |     cout<<kruskal();
45 |     return 0;
46 | }
47 | 


--------------------------------------------------------------------------------
/201709-1 打酱油 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int solve(int n)
 4 | {
 5 |     if(n<50)
 6 |         return n<30?n/10:4+(n-30)/10;
 7 |     return max(4+solve(n-30),7+solve(n-50));
 8 | }
 9 | int main()
10 | {
11 |     int n;
12 |     cin>>n;
13 |     cout<<solve(n);
14 |     return 0;
15 | }
16 | 


--------------------------------------------------------------------------------
/201709-2 公共钥匙盒 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | struct teacher
 4 | {
 5 |     int num,s,e;
 6 |     teacher(int x=0,int y=0,int z=0):num(x),s(y),e(z){}
 7 | };
 8 | vector<teacher> p,q;
 9 | int keyn,tean;
10 | int key[1024];
11 | bool cmpp(const teacher &a,const teacher &b)
12 | {
13 |     return a.s<b.s;
14 | }
15 | bool cmpq(const teacher &a,const teacher &b)
16 | {
17 |     return a.e==b.e?a.num<b.num:a.e<b.e;
18 | }
19 | int searchkeypos(int keyid)
20 | {
21 |     for(int i=1;i<=keyn;++i)
22 |         if(keyid==key[i]) return i;
23 |     cout<<"can't find "<<keyid<<endl;
24 |     return -1;
25 | }
26 | int main()
27 | {
28 |     cin>>keyn>>tean;
29 |     for(int i=1;i<=keyn;++i)
30 |         key[i]=i;
31 |     for(int i=0;i<tean;++i)
32 |     {
33 |         teacher x;
34 |         cin>>x.num>>x.s>>x.e;
35 |         x.e+=x.s;
36 |         p.push_back(x);
37 |         q.push_back(x);
38 |     }
39 |     sort(p.begin(),p.end(),cmpp);
40 |     sort(q.begin(),q.end(),cmpq);
41 |     int i=0,j=0;
42 |     while(i<tean&&j<tean)
43 |     {
44 |         if(p[i].s<q[j].e)
45 |         {
46 |             int pos=searchkeypos(p[i++].num);
47 |             key[pos]=-1;
48 |         }
49 |         else if(p[i].s>=q[j].e)
50 |         {
51 |             int pos=searchkeypos(-1);
52 |             key[pos]=q[j++].num;
53 |         }
54 |     }
55 |     while(j<tean)
56 |     {
57 |         int pos=searchkeypos(-1);
58 |         key[pos]=q[j++].num;
59 |     }
60 |     for(int i=1;i<=keyn;++i)
61 |         cout<<key[i]<<" ";
62 |     return 0;
63 | }
64 | 


--------------------------------------------------------------------------------
/201709-3 JSON查询 ccf .cpp:
--------------------------------------------------------------------------------
  1 | #include <bits/stdc++.h>
  2 | using namespace std;
  3 | bool isroot(string &jsonstr,size_t pos)
  4 | {
  5 |     int pcnt=0;
  6 |     for(size_t i=0;i<pos;++i)
  7 |     {
  8 |         if(jsonstr[i]=='{') ++pcnt;
  9 |         if(jsonstr[i]=='}') --pcnt;
 10 |     }
 11 |     return pcnt==0;
 12 | }
 13 | vector<string> split(string str)
 14 | {
 15 |     size_t pos=str.find(".");
 16 |     vector<string> ret;
 17 |     while(pos!=string::npos)
 18 |     {
 19 |         ret.push_back(str.substr(0,pos));
 20 |         str=str.substr(pos+1);
 21 |         pos=str.find(".");
 22 |     }
 23 |     ret.push_back(str);
 24 |     return ret;
 25 | }
 26 | string subjsonstr(string jsonstr,int lpos)
 27 | {
 28 |     int pcnt=1;
 29 |     size_t rpos=lpos;
 30 |     while(pcnt)
 31 |     {
 32 |         if(jsonstr[rpos]=='{')
 33 |             pcnt++;
 34 |         else if(jsonstr[rpos]=='}')
 35 |             pcnt--;
 36 |         ++rpos;
 37 |     }
 38 |     return jsonstr.substr(lpos,rpos-lpos-1)+",";
 39 | }
 40 | void search(vector<string> &ret,string jsonstr)
 41 | {
 42 |     size_t i=0;
 43 |     while(i<ret.size()-1)
 44 |     {
 45 |         size_t pos=jsonstr.find(ret[i]+":{");
 46 |         if(pos==string::npos||!isroot(jsonstr,pos))
 47 |         {
 48 |             cout<<"NOTEXIST\n";
 49 |             return;
 50 |         }
 51 |         jsonstr=subjsonstr(jsonstr,pos+ret[i].size()+2);
 52 |         ++i;
 53 |     }
 54 |     size_t pos=jsonstr.find(ret.back()+":");
 55 |     if(pos==string::npos||!isroot(jsonstr,pos))
 56 |     {
 57 |         cout<<"NOTEXIST\n";
 58 |     }
 59 |     else
 60 |     {
 61 |         i=pos+ret.back().size()+1;
 62 |         if(jsonstr[i]=='{')
 63 |             cout<<"OBJECT\n";
 64 |         else
 65 |         {
 66 |             size_t dp=jsonstr.find(",",i);
 67 |             if(dp==string::npos)
 68 |             {
 69 |                 cout<<"NOTEXIST\n";
 70 |                 return;
 71 |             }
 72 |             string x;
 73 |             while(i<dp)
 74 |                 x+=jsonstr[i++];
 75 |             cout<<"STRING "<<x<<endl;
 76 |         }
 77 |     }
 78 | }
 79 | int main()
 80 | {
 81 |     //freopen("1.txt","r",stdin);
 82 |     string jsonstr;
 83 |     int n,m;
 84 |     cin>>n>>m;
 85 |     cin.get();
 86 |     cin.get();
 87 |     for(int i=0;i<n;++i)
 88 |     {
 89 |         char ch;
 90 |         while((ch=cin.get())!='\n')
 91 |         {
 92 |             if(ch==' '||ch=='"') continue;
 93 |             if(ch=='\\')
 94 |             {
 95 |                 jsonstr+=cin.get();
 96 |                 continue;
 97 |             }
 98 |             jsonstr+=ch;
 99 |         }
100 |     }
101 |     jsonstr[jsonstr.length()-1]=',';
102 |     while(m--)
103 |     {
104 |         string str;
105 |         cin>>str;
106 |         vector<string> ret=split(str);
107 |         search(ret,jsonstr);
108 |     }
109 |     return 0;
110 | }
111 | 


--------------------------------------------------------------------------------
/201709-4 通信网络 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | vector<int> v[1024];
 4 | int isconnect[1024][1024];
 5 | void dfsSolve(int u,int visit[],int cur)
 6 | {
 7 |     visit[u]=1;
 8 |     isconnect[u][cur]=isconnect[cur][u]=1;
 9 |     for(size_t i=0;i<v[u].size();++i)
10 |     {
11 |         if(visit[v[u][i]]==0)
12 |             dfsSolve(v[u][i],visit,cur);
13 |     }
14 | }
15 | int main()
16 | {
17 |     int n,m,total=0;
18 |     cin>>n>>m;
19 |     for(int i=0;i<m;++i)
20 |     {
21 |         int s,e;
22 |         cin>>s>>e;
23 |         v[s].push_back(e);
24 |     }
25 |     for(int i=1;i<=n;++i)
26 |     {
27 |         int visit[1024]={0};
28 |         dfsSolve(i,visit,i);
29 |     }
30 |     for(int i=1;i<=n;++i)
31 |     {
32 |         int j;
33 |         for(j=1;j<=n;++j) 
34 |             if(isconnect[i][j]==0)break;
35 |         if(j==n+1)++total;
36 |     }
37 |     cout<<total;
38 |     return 0;
39 | }
40 | 


--------------------------------------------------------------------------------
/201709-5 除法 ccf .cpp:
--------------------------------------------------------------------------------
 1 | #include <cstdio>
 2 | long long tree[101024];
 3 | int n,m,a[101024];
 4 | void update(int i,int val)
 5 | {
 6 |     while(i<=n)
 7 |     {
 8 |         tree[i]+=val;
 9 |         i+=-i&i;
10 |     }
11 | }
12 | long long getsum(int i)
13 | {
14 |     long long sum=0;
15 |     while(i>0)
16 |     {
17 |         sum+=tree[i];
18 |         i-=-i&i;
19 |     }
20 |     return sum;
21 | }
22 | int main()
23 | {
24 |     scanf("%d %d",&n,&m);
25 |     for(int i=1;i<=n;++i)
26 |     {
27 |         scanf("%d",&a[i]);
28 |         update(i,a[i]);
29 |     }
30 |     for(int i=1;i<=m;++i)
31 |     {
32 |         int opt,l,r,w;
33 |         scanf("%d %d %d",&opt,&l,&r);
34 |         if(opt==2) printf("%lld\n",getsum(r)-getsum(l-1));
35 |         else
36 |         {
37 |             scanf("%d",&w);
38 |             if(w==1)continue;
39 |             while(l<=r)
40 |             {
41 |                 if(a[l]>=w&&a[l]%w==0)
42 |                 {
43 |                     update(l,-(a[l]-a[l]/w));
44 |                     a[l]/=w;
45 |                 }
46 |                 ++l;
47 |             }
48 |         }
49 |     }
50 |     return 0;
51 | }
52 | 


--------------------------------------------------------------------------------
/201712-1 最小差值 ccf.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int a[1024],n;
 6 |     scanf("%d",&n);
 7 |     for(int i=0;i<n;++i)
 8 |         scanf("%d",&a[i]);
 9 |     sort(a,a+n);
10 |     int i=1,minval=999999;
11 |     while(i<n)
12 |     {
13 |         minval=min(minval,a[i]-a[i-1]);
14 |         ++i;
15 |     }
16 |     printf("%d\n",minval);
17 |     return 0;
18 | }
19 | 


--------------------------------------------------------------------------------
/201712-2 游戏 ccf.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 | 	vector<int> v;
 6 | 	int n,k;
 7 | 	cin>>n>>k;
 8 | 	for(int i=1;i<=n;++i)
 9 | 		v.push_back(i);
10 | 	int num=0;
11 | 	while(v.size()>1)
12 | 	{
13 | 		n=v.size();
14 | 		int len=0;
15 | 		for(int i=0;i<n;++i)
16 | 		{
17 | 			++num;
18 | 			if(num%k&&num%10!=k) v[len++]=v[i];
19 | 		}
20 | 		if(len==0) v[len++]=v.back();
21 | 		v.resize(len);
22 | 	}
23 | 	cout<<v[0]<<endl;
24 | 	return 0;
25 | }
26 | 


--------------------------------------------------------------------------------
/201712-3 Crontab ccf.cpp:
--------------------------------------------------------------------------------
  1 | #include <bits/stdc++.h>
  2 | using namespace std;
  3 | char vMon[][4]={"","jan","feb","mar","apr","may","jun","jul","aug","sep","oct","nov","dec"};
  4 | char vWek[][4]={"sun","mon","tue","wed","thu","fri","sat"};
  5 | int mtharray[]={0,31,28,31,30,31,30,31,31,30,31,30,31};
  6 | map<string,int> mMon,mWek;
  7 | map<string,vector<string> > mrt;
  8 | void buildMonAndWekMap()
  9 | {
 10 |     for(int i=1;i<=12;++i) mMon[vMon[i]]=i;//月份
 11 |     for(int i=0;i<=6;++i) mWek[vWek[i]]=i;//星期
 12 | }
 13 | string to_string_x(int n)//c++11 surport
 14 | {
 15 |     stringstream ss;
 16 |     ss<<n;
 17 |     return ss.str();
 18 | }
 19 | int stoi_x(const string &str)//c++11 surport
 20 | {
 21 |     int ans;
 22 |     stringstream ss(str);
 23 |     ss>>ans;
 24 |     return ans;
 25 | }
 26 | void toStandard(string &str)//转化为标准小写 
 27 | {
 28 |     int len=str.size();
 29 |     for(int i=0;i<len;++i)str[i]=tolower(str[i]);
 30 | }
 31 | vector<string> splitStringAndbuildVector(string &str,int TAG)//TAG=0(other),1(month),2(dayofweek);
 32 | {
 33 |     str+=",";
 34 |     vector<string> vret;
 35 |     size_t found=str.find(",");
 36 |     while(found!=string::npos)
 37 |     {
 38 |         string x=str.substr(0,found);
 39 |         str=str.substr(found+1,str.size()-found-1);
 40 |         size_t fdx=x.find("-");
 41 |         if(fdx==string::npos)//非连续值 
 42 |         {
 43 |             if(TAG==1&&isalpha(x[0])) x=to_string_x(mMon[x]);//是month英文缩写，转换为数字
 44 |             if(TAG==2&&isalpha(x[0])) x=to_string_x(mWek[x]);//是day of week英文缩写，转换为数字
 45 |             if(x.size()==1) x="0"+x;//添加0
 46 |             vret.push_back(x);
 47 |         }
 48 |         else//连续值 
 49 |         {
 50 |             string L=x.substr(0,fdx),R=x.substr(fdx+1,x.size()-fdx-1);
 51 |             int left,right;
 52 |             if(TAG==0) left=stoi_x(L),right=stoi_x(R);
 53 |             else if(TAG==1)//month
 54 |             {
 55 |                 left=(isalpha(L[0]))?mMon[L]:stoi_x(L);
 56 |                 right=(isalpha(R[0]))?mMon[R]:stoi_x(R);
 57 |             }
 58 |             else if(TAG==2)//day of week
 59 |             {
 60 |                 left=(isalpha(L[0]))?mWek[L]:stoi_x(L);
 61 |                 right=(isalpha(R[0]))?mWek[R]:stoi_x(R);
 62 |             }
 63 |             while(left<=right)
 64 |             {
 65 |                 string num=to_string_x(left);
 66 |                 if(num.size()==1)num="0"+num;
 67 |                 vret.push_back(num);
 68 |                 ++left;
 69 |             } 
 70 |         }
 71 |         found=str.find(",");
 72 |     }
 73 |     return vret;
 74 | }
 75 | bool isleapyear(int y)
 76 | {
 77 |     return (y%4==0&&y%100)||y%400==0;
 78 | }
 79 | string getWeekday(string year,string month,string day)
 80 | {
 81 |     int y=stoi_x(year),m=stoi_x(month),d=stoi_x(day);
 82 |     int by=1970,countday=0;
 83 |     while(by<y)
 84 |     {
 85 |         countday+=(isleapyear(by))?366:365;
 86 |         ++by; 
 87 |     }
 88 |     for(int i=1;i<m;++i) countday+=mtharray[i];
 89 |     countday+=d-1;
 90 |     return "0"+to_string_x((4+countday%7)%7);
 91 | }
 92 | int main()
 93 | {
 94 |     int n;
 95 |     string st,et;
 96 |     buildMonAndWekMap();
 97 |     cin>>n>>st>>et;
 98 |     string syy=st.substr(0,4),smm=st.substr(4,2),sdd=st.substr(6,2),sHH=st.substr(8,2),sMM=st.substr(10,2);
 99 |     string eyy=et.substr(0,4),emm=et.substr(4,2),edd=et.substr(6,2),eHH=et.substr(8,2),eMM=et.substr(10,2);
100 |     int syInt=stoi_x(syy),eyInt=stoi_x(eyy);
101 |     while(n--)
102 |     {
103 |         vector<string> vmts,vhur,vdfm,vmth,vdfw;
104 |         string minutes,hours,dofmon,month,dofwek,command;
105 |         cin>>minutes>>hours>>dofmon>>month>>dofwek>>command;
106 |         toStandard(month);//不区别大小写，转化为标准小写 
107 |         toStandard(dofwek);//不区别大小写，转化为标准小写 
108 |         if(minutes=="*") minutes="0-59";
109 |         vmts=splitStringAndbuildVector(minutes,0);//应该执行的分钟 
110 |         if(hours=="*") hours="0-23";
111 |         vhur=splitStringAndbuildVector(hours,0); //应该执行的小时
112 |         if(dofmon=="*") dofmon="1-31";
113 |         vdfm=splitStringAndbuildVector(dofmon,0);//应该执行的日期
114 |         if(month=="*") month="1-12";
115 |         vmth=splitStringAndbuildVector(month,1);//应该执行的月份 
116 |         if(dofwek=="*") dofwek="0-6";
117 |         vdfw=splitStringAndbuildVector(dofwek,2);//应该周几执行 
118 |         set<string> wekexist;
119 |         for(size_t i=0;i<vdfw.size();++i) wekexist.insert(vdfw[i]);//更快的检索当前日期（dayofweek）是不是应该执行 
120 |         int curyear=syInt;//从开始年份执行 
121 |         while(curyear<=eyInt)
122 |         {
123 |             if(isleapyear(curyear)) mtharray[2]=29;//leapyear的2月份应该是29天 
124 |             else mtharray[2]=28;
125 |             string year=to_string_x(curyear);//年份 
126 |             for(size_t mi=0;mi<vmth.size();mi++)//month
127 |             {
128 |                 string curm=vmth[mi];//当前月份 
129 |                 for(size_t di=0;di<vdfm.size();di++)//day of month
130 |                 {
131 |                     string curd=vdfm[di];//当前日期 
132 |                     string wd=getWeekday(year,curm,curd);//该年，该月，该日是星期几 
133 |                     if(wekexist.count(wd)==0||stoi_x(curd)>mtharray[stoi_x(curm)])continue;
134 |                     //命令行中不包含该星期或者当前天数超过当前月份的应有天数时 
135 |                     for(size_t Hi=0;Hi<vhur.size();++Hi)//hour
136 |                     {
137 |                         for(size_t Mi=0;Mi<vmts.size();++Mi)//minutes
138 |                         {
139 |                             string datetime=year+curm+curd+vhur[Hi]+vmts[Mi];
140 |                             if(datetime>=st&&datetime<et) mrt[datetime].push_back(command);//在当前日期时间内 
141 |                         }
142 |                     }
143 |                 }
144 |             }
145 |             ++curyear;//进入下一年 
146 |         }
147 |     }
148 |     for(map<string,vector<string> >::iterator it=mrt.begin();it!=mrt.end();++it)
149 |     {
150 |         map<string,int> isprt;
151 |         for(size_t i=0;i<it->second.size();++i)
152 |         {
153 |             string dis=it->first+" "+it->second[i];
154 |             if(isprt.count(dis)==0)
155 |             {
156 |                 cout<<dis<<endl;
157 |                 isprt[dis]=1;
158 |             }
159 |         }
160 |     }
161 |     return 0;
162 | }
163 | 


--------------------------------------------------------------------------------
/201712-4 行车路线 ccf.cpp:
--------------------------------------------------------------------------------
  1 | /*
  2 | 该代码存在一些问题，对于评论区的一些测试用例不能通过，具体查看http://blog.csdn.net/gl486546/article/details/79060030
  3 | */
  4 | #include <bits/stdc++.h>
  5 | using namespace std;
  6 | typedef long long llt;
  7 | const llt inf=0x7fffffffffffffff;
  8 | llt sA[512][512],bA[512][512];
  9 | llt n,m;
 10 | 
 11 | llt sqe(llt x){return x*x;}//返回平方
 12 | llt dijkstra()
 13 | {
 14 | 	bool visitsr[512]={0},visitbr[512]={0};
 15 | 	vector<llt> sr(sA[0],sA[0]+n),br(bA[0],bA[0]+n),presr(n,inf);
 16 | 	for(llt i=0;i<n;++i)
 17 | 	{
 18 | 		if(sr[i]<inf)
 19 | 		{
 20 | 			presr[i]=sr[i];
 21 | 			sr[i]*=sr[i];
 22 | 		}
 23 | 	}
 24 | 	visitsr[0]=visitbr[0]=1;
 25 | 	while(true)
 26 | 	{
 27 | 		llt minval=inf,u=-1,flag=0;
 28 | 		for(llt i=0;i<n;++i)//找到一条最短路径，并且用flag标记是大路还是小路
 29 | 		{
 30 | 			if(!visitbr[i]&&minval>br[i])
 31 | 			{
 32 | 				minval=br[u=i];
 33 | 				flag=0;//大路
 34 | 			}
 35 | 			if(!visitsr[i]&&minval>sr[i])
 36 | 			{
 37 | 				minval=sr[u=i];
 38 | 				flag=1;//小路
 39 | 			}
 40 | 		}
 41 | 		if(u==-1)break;
 42 | 		if(flag==1) visitsr[u]=1;
 43 | 		else visitbr[u]=1;
 44 | 		for(llt w=0;w<n;++w)
 45 | 		{
 46 | 			if(!visitsr[w]&&sA[u][w]<inf)//从u到w存在一条小路
 47 | 			{
 48 | 				if(flag==1)//u前驱是小路
 49 | 				{
 50 | 					llt len=sr[u]-sqe(presr[u])+sqe(presr[u]+sA[u][w]);
 51 | 					if(sr[w]>len||(sr[w]==len&&presr[w]>presr[u]+sA[u][w]))
 52 | 					{
 53 | 						sr[w]=len;
 54 | 						presr[w]=presr[u]+sA[u][w];
 55 | 					}
 56 | 				}
 57 | 				else//u前驱是大路
 58 | 				{
 59 | 					llt len=br[u]+sqe(sA[u][w]);
 60 | 					if(sr[w]>len||(sr[w]==len&&presr[w]>sA[u][w]))
 61 | 					{
 62 | 						sr[w]=len;
 63 | 						presr[w]=sA[u][w];
 64 | 					}
 65 | 				}
 66 | 			}
 67 | 			if(!visitbr[w]&&bA[u][w]<inf)//从u到w存在一条大路
 68 | 			{
 69 | 				if(flag==1)//u前驱是小路
 70 | 				{
 71 | 					llt len=sr[u]+bA[u][w];
 72 | 					br[w]=min(len,br[w]);
 73 | 				}
 74 | 				else//u前驱是大路
 75 | 				{
 76 | 					llt len=br[u]+bA[u][w];
 77 | 					br[w]=min(len,br[w]);
 78 | 				}
 79 | 			}
 80 | 		}
 81 | 	}
 82 | 	return min(sr[n-1],br[n-1]);
 83 | }
 84 | int main()
 85 | {
 86 |     scanf("%lld %lld",&n,&m);
 87 |     for(llt i=0;i<n;++i)
 88 |     {
 89 |         for(llt j=0;j<n;++j)
 90 |         {
 91 |         	sA[i][j]=sA[j][i]=inf;
 92 |         	bA[i][j]=bA[j][i]=inf;
 93 |         }
 94 |     }
 95 |     for(llt i=0;i<m;++i)
 96 |     {
 97 |         llt t,a,b,c;
 98 |         scanf("%lld %lld %lld %lld",&t,&a,&b,&c);
 99 |         --a,--b;
100 |         if(t==1) sA[a][b]=sA[b][a]=min(c,sA[a][b]);
101 |         else bA[a][b]=bA[b][a]=min(c,bA[a][b]);
102 |     }
103 |     llt ret=dijkstra();
104 |     printf("%lld\n",ret);
105 |     return 0;
106 | }
107 | 


--------------------------------------------------------------------------------
/201803-1 跳一跳 ccf.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     vector<int> nums;
 6 |     int x;
 7 |     while(scanf("%d",&x)==1&&x){
 8 |         nums.push_back(x);
 9 |     }
10 |     int n=nums.size();
11 |     for(int i=0,j=1;j<n;++i,++j){
12 |         if(!(nums[j]&1)&&!(nums[i]&1)){
13 |             nums[j]+=nums[i];
14 |         }
15 |     }
16 |     int scores=accumulate(nums.begin(),nums.end(),0);
17 |     printf("%d\n",scores);
18 |     return 0;
19 | }
20 | 


--------------------------------------------------------------------------------
/201803-2 碰撞的小球 ccf.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     typedef pair<int,int> P;
 6 |     vector<P> balls;
 7 |     int n,L,t;
 8 |     scanf("%d %d %d",&n,&L,&t);
 9 |     for(int i=0;i<n;++i){
10 |         int pos;
11 |         scanf("%d",&pos);
12 |         balls.push_back(make_pair(pos,1));
13 |     }
14 |     while(t--){
15 |         for(int i=0;i<n;++i){
16 |             if(balls[i].first==0||balls[i].first==L){
17 |                 balls[i].second*=-1;
18 |             }
19 |             balls[i].first+=balls[i].second;
20 |         }
21 |         for(int i=0;i<n;++i){
22 |             for(int j=i+1;j<n;++j){
23 |                 if(balls[i].first==balls[j].first){
24 |                     balls[i].second*=-1;
25 |                     balls[j].second*=-1;
26 |                 }
27 |             }
28 |         }
29 |     }
30 |     for(int i=0;i<n;++i){
31 |         printf("%d ",balls[i].first);
32 |     }
33 |     return 0;
34 | }
35 | 


--------------------------------------------------------------------------------
/201803-3 URL映射 ccf.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | struct regulation{
 4 |     string name;
 5 |     vector<string> regv;
 6 |     regulation(string a,vector<string> v):name(a),regv(v){}
 7 | };
 8 | vector<regulation> regulations;
 9 | vector<string> str2regv(string str){
10 |     vector<string> res;
11 |     str=str.substr(1,str.size()-1);
12 |     res.push_back("/");
13 |     size_t pos=str.find("/");
14 |     while(pos!=string::npos){
15 |         res.push_back(str.substr(0,pos));
16 |         res.push_back("/");
17 |         str=str.substr(pos+1);
18 |         pos=str.find("/");
19 |     }
20 |     if(str.size()) res.push_back(str);
21 |     return res;
22 | }
23 | void urlmap(string str){
24 |     vector<string> v=str2regv(str);
25 |     for(size_t i=0;i<regulations.size();++i){
26 |         vector<string> &r=regulations[i].regv;
27 |         string res=regulations[i].name;
28 |         size_t lr=r.size(),lv=v.size(),j=0,k=0;
29 |         while(j<lr&&k<lv){
30 |             if(r[j]==v[k]){
31 |                 ++j,++k;continue;
32 |             }
33 |             if(r[j]=="<path>"){
34 |                 if(v[lv-1]=="/") break;
35 |                 res+=" ";
36 |                 while(k<lv){
37 |                     res+=v[k++];
38 |                 }
39 |                 cout<<res<<endl;
40 |                 return;
41 |             }else if(r[j]=="<int>"){
42 |                 string num;
43 |                 bool tag=1;
44 |                 for(size_t l=0;l<v[k].size();++l){
45 |                     if(isdigit(v[k][l])) num+=v[k][l];
46 |                     else {
47 |                         tag=0;break;
48 |                     }
49 |                 }
50 |                 if(tag==0) break;
51 |                 size_t uz=0;
52 |                 while(num[uz]=='0'&&uz<num.size()-1) ++uz;
53 |                 res+=" "+num.substr(uz,num.size()-uz);
54 |             }else if(r[j]=="<str>"){
55 |                 res+=" "+v[k];
56 |             }else break;
57 |             ++j;++k;
58 |         }
59 |         if(j==lr&&k==lv){
60 |             cout<<res<<endl;
61 |             return;
62 |         }
63 |     }
64 |     cout<<"404"<<endl;
65 | }
66 | int main()
67 | {
68 |     int n,m;
69 |     cin>>n>>m;
70 |     for(int i=0;i<n;++i){
71 |         string regstr,name;
72 |         cin>>regstr>>name;
73 |         regulations.push_back(regulation(name,str2regv(regstr)));
74 |     }
75 |     while(m--){
76 |         string str;
77 |         cin>>str;
78 |         urlmap(str);
79 |     }
80 |     return 0;
81 | }
82 | 


--------------------------------------------------------------------------------
/201803-4 棋局评估 ccf.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int A[3][3];//棋盘
 5 | bool rck(int i,int val){//横向
 6 |     return A[i][0]==val&&A[i][1]==val&&A[i][2]==val;
 7 | }
 8 | bool cck(int j,int val){//竖向
 9 |     return A[0][j]==val&&A[1][j]==val&&A[2][j]==val;
10 | }
11 | bool dck(int val){//斜向
12 |     return (A[0][0]==val&&A[1][1]==val&&A[2][2]==val)||(A[0][2]==val&&A[1][1]==val&&A[2][0]==val);
13 | }
14 | int zeroCpt(){//计算空白格子个数（分数）
15 |     int res=0;
16 |     for(int i=0;i<3;++i){
17 |         for(int j=0;j<3;++j){
18 |             if(A[i][j]==0) res++;
19 |         }
20 |     }
21 |     return res;
22 | }
23 | int win(int player){//player=1代表Alice, player=2代表Bob
24 |     bool r=rck(0,player)||rck(1,player)||rck(2,player);
25 |     bool c=cck(0,player)||cck(1,player)||cck(2,player);
26 |     bool d=dck(player);
27 |     int w=r||c||d;//当前状态玩家player是否胜出
28 |     if(w==0) return 0;//未胜出，棋局还未结束
29 |     w=zeroCpt()+1;//player胜出，返回分数，棋局结束
30 |     return player==1?w:-w;
31 | }
32 | int dfs(int player){
33 |     if(zeroCpt()==0) return 0;//平局
34 |     int Min=10,Max=-10;
35 |     for(int i=0;i<3;++i){
36 |         for(int j=0;j<3;++j){
37 |             if(A[i][j]==0){
38 |                 A[i][j]=player;
39 |                 int w=win(player);
40 |                 if(w){//棋局结束
41 |                     A[i][j]=0;
42 |                     return w>0?max(Max,w):min(Min,w);
43 |                 }
44 |                 if(player==1) Max=max(Max,dfs(2));
45 |                 else Min=min(Min,dfs(1));
46 |                 A[i][j]=0;
47 |             }
48 |         }
49 |     }
50 |     return player==1?Max:Min;
51 | }
52 | int main()
53 | {
54 |     int T;
55 |     scanf("%d",&T);
56 |     while(T--){
57 |         for(int i=0;i<3;++i){
58 |             for(int j=0;j<3;++j){
59 |                 scanf("%d",&A[i][j]);
60 |             }
61 |         }
62 |         int x=win(1),y=win(2);
63 |         if(x) printf("%d\n",x);
64 |         else if(y) printf("%d\n",y);
65 |         else printf("%d\n",dfs(1));
66 |     }
67 |     return 0;
68 | }
69 | 


--------------------------------------------------------------------------------
/201809-1 卖菜 ccf.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int A[10010], B[10010];
 4 | int main()
 5 | {
 6 |     int n;
 7 |     scanf("%d", &n);
 8 |     for(int i = 0; i < n; ++i){
 9 |         scanf("%d", A + i);
10 |     }
11 |     B[0] = (A[0] + A[1]) / 2;
12 |     B[n - 1] = (A[n - 1] + A[n - 2]) / 2;
13 |     for(int i = 1; i <= n -2; ++i){
14 |         B[i] = (A[i - 1] + A[i] + A[i + 1]) / 3;
15 |     }
16 |     for(int i = 0; i < n; ++i){
17 |         printf("%d ", B[i]);
18 |     }
19 |     return 0;
20 | }
21 | 


--------------------------------------------------------------------------------
/201809-2 买菜 ccf.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int a[10000000];
 4 | void rd(int n){
 5 | 	for(int i = 0; i < n; ++i){
 6 | 		int l, r;
 7 | 		scanf("%d %d", &l, &r);
 8 | 		while(l < r) a[l++]++; 
 9 | 	}
10 | }
11 | int main()
12 | {
13 | 	int n;
14 | 	scanf("%d", &n);
15 | 	rd(n);
16 | 	rd(n);
17 | 	int sum;
18 | 	for(int i = 1; i < 1000000; ++i){
19 | 		if(a[i] == 2) ++sum;
20 | 	}
21 | 	printf("%d\n", sum);
22 | 	return 0;
23 | }
24 | 


--------------------------------------------------------------------------------
/201809-3 元素选择器 ccf.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | struct node{
 4 |     int r, lev;//r:行索引，唯一标识；lev:层次序，用于建树
 5 |     string label, id;
 6 | };
 7 | int n, m;
 8 | vector<node> v;//输入节点数据
 9 | vector<int> vx[128];//邻接表
10 | void convert(string &s){
11 |     if(s[0] == '#') return;
12 |     for(char &x : s) x = tolower(x);
13 | }
14 | void mk(string &s, int i){//创建节点
15 |     int dotnums = 0;
16 |     while(s[dotnums] == '.') ++dotnums;
17 |     v[i].lev = dotnums / 2;
18 |     v[i].r = i;
19 |     size_t p = s.find(" ");
20 |     if(p != string::npos){//包含属性id
21 |         v[i].label = s.substr(dotnums, p - dotnums);
22 |         v[i].id = s.substr(p + 1);
23 |     }else{//不包含
24 |         v[i].label = s.substr(dotnums);
25 |         v[i].id = "";
26 |     }
27 |     convert(v[i].label);
28 | }
29 | vector<string> split(string &s){
30 |     vector<string> vs;
31 |     s += " ";
32 |     size_t p;
33 |     while((p = s.find(" ", 0)) != string::npos){
34 |         vs.push_back(s.substr(0, p));
35 |         s = s.substr(p + 1);
36 |         convert(vs.back());
37 |     }
38 |     return vs;
39 | }
40 | void dfs(int i, string &s, map<int, int> &res){//找到以i为根，后代节点中label或者id等于s的行索引
41 |     for(int k : vx[i]){
42 |         if(v[k].label == s || v[k].id == s) res[k] = 1;
43 |         dfs(k, s, res);
44 |     }
45 | }
46 | int main()
47 | {
48 |     //freopen("1.txt", "r", stdin);
49 |     cin >> n >> m;
50 |     getchar();
51 |     v.resize(n + 1);
52 |     for(int i = 1; i <= n; ++i){
53 |         string s;
54 |         getline(cin, s);
55 |         mk(s, i);
56 |     }
57 |     int i = n;
58 |     while(i >= 1){//建树
59 |         int j = i - 1;
60 |         while(j >= 1 && v[j].lev >= v[i].lev) --j;
61 |         vx[j].push_back(i);
62 |         --i;
63 |     }
64 |     while(m--){
65 |         string s;
66 |         getline(cin, s);
67 |         vector<string> vs = split(s);
68 |         map<int, int> res;
69 |         dfs(0, vs[0], res);
70 |         int L = vs.size(), i = 1;
71 |         while(i < L){
72 |             map<int, int> temp = res, vsum;
73 |             for(auto x : temp){
74 |                 res.clear();
75 |                 dfs(x.first, vs[i], res);
76 |                 for(auto y : res) vsum[y.first] = 1;
77 |             }
78 |             res = vsum;++i;
79 |         }
80 |         cout << res.size();
81 |         for(auto x : res) cout << " " << x.first;
82 |         cout << endl;
83 |     }
84 |     return 0;
85 | }
86 | 


--------------------------------------------------------------------------------
/201809-4 再卖菜 ccf.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | 
 4 | int day2[400], day1[400], n;
 5 | bool isfind = 0, isvis[400][400][400];
 6 | void dfs(int i, int cur, int pre){
 7 | 	if(isvis[i][cur][pre]) return;//当前状态已经搜索过，进行剪枝
 8 | 	isvis[i][cur][pre] = 1;
 9 | 	day1[i] = cur;
10 | 	if(i == n){
11 | 		if((day1[n - 1] + day1[n]) / 2 == day2[n]) isfind = 1;//核对最后一天
12 | 		return;
13 | 	}
14 | 	int next = 3*day2[i] - pre - cur;//对第i天，如果该天cur，以及昨天pre确定，那么下一天有3种情况
15 | 	for(int k = 0; k < 3; ++k){//0, 1, 2
16 | 		if(next + k > 0 && !isfind){//注意next + k必须为正整数
17 | 			dfs(i + 1, next + k, cur);
18 | 		}
19 | 	}
20 | }
21 | int main()
22 | {
23 | 	scanf("%d", &n);
24 | 	for(int i = 1; i <= n; ++i){
25 | 		scanf("%d", day2 + i);
26 | 	}
27 | 	for(int e = 1; e <= 2*day2[1]; ++e){
28 | 		day1[1] = e;//第一天确定，那么第二天也能确定，有两种情况
29 | 		dfs(2, 2*day2[1] - e, day1[1]);
30 | 		if(!isfind) dfs(2, 2*day2[1] - e + 1, e);
31 | 		else break;
32 | 	}
33 | 	for(int i = 1; i <= n; ++i){
34 | 		printf("%d ", day1[i]);
35 | 	}
36 | 	return 0;
37 | }
38 | 


--------------------------------------------------------------------------------
/201812-1 小明上学 ccf.cpp:
--------------------------------------------------------------------------------
 1 | #include <bits/stdc++.h>
 2 | using namespace std;
 3 | int main()
 4 | {
 5 |     int r, y, g, n;
 6 |     cin >> r >> y >> g;
 7 |     cin >> n;
 8 |     int sum = 0;
 9 |     for(int i = 0; i < n; i++){
10 |         int k, t;
11 |         cin >> k >> t;
12 |         if(k == 0) sum += t;
13 |         else if(k == 1) sum += t;
14 |         else if(k == 2) sum += t + r;
15 |         else if(k == 3) sum += 0;
16 |     }
17 |     cout << sum;
18 |     return 0;
19 | }
20 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | # ccf csp
 2 | 
 3 | ### ccf题解（部分）
 4 | 
 5 | **Edit by L_Aster**
 6 | 
 7 | ccf计算机职业资格认证的题解，官网链接：http://www.cspro.org/lead/application/ccf/login.jsp
 8 | 
 9 | 博客题解索引：http://blog.csdn.net/gl486546/article/details/79112507
10 | 


--------------------------------------------------------------------------------