CCPC-Wannafly Summer Camp 2019 Day1

最新推荐文章于 2019-08-02 16:38:57 发布
最新推荐文章于 2019-08-02 16:38:57 发布
阅读量198 收藏
点赞数
分类专栏： 最短路径 递推 Codeforces
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zeolim/article/details/97776341
版权

A - Jzzhu and Cities

 题目大意：给个图，m条普通边，k条特殊边，保证1到N的最短路上最多可以删掉几条特殊边使得最短路不变。

解法1：跑最短路后松弛一遍所有边，如果松弛时既有普通和特殊则可去掉特殊铁路。

解法2：直接重载搜索顺序使得迪杰斯特拉优先跑普通铁路，再记录总特殊条数-跑的条数即为答案。

/*
    Zeolim - An AC a day keeps the bug away
*/

//pragma GCC optimize(2)
#include <bits/stdc++.h>
typedef long long ll;
typedef long double ld;
typedef std::pair<int, int> pii;
//typedef __int128 ill;
const ld PI = acos(-1.0);
const ld E = exp(1.0);
const ll INF = 0x3f3f3f3f;
const ll MOD = 1e9 + 7;
using namespace std;
const int MAXN = 1e6 + 10;

int n, m, k;


bool used[MAXN];

struct node
{
	ll to, val, ok;
	node() { }
	node(ll a, ll b, ll c) { to = a, val = b, ok = c; }
};

vector <node> edge[MAXN];

struct bfsnode
{
	ll now, dis, cnt;
	bfsnode() { }
	bfsnode(ll a, ll b, ll c) { now = a, dis = b, cnt = c; }
};

bool operator < (bfsnode a, bfsnode b)
{
	if(a.dis == b.dis)
		return a.cnt > b.cnt;
	return a.dis > b.dis; 
 } 

void bfs()
{
	priority_queue <bfsnode> PQ;
	
	PQ.push(bfsnode(1, 0, 0));
	
	ll ans = 0;
	
	while(!PQ.empty())
	{
		bfsnode rnow = PQ.top();
		PQ.pop();
		
		if(used[rnow.now])
			continue;
			
		used[rnow.now] = true;
		
		if(rnow.cnt)
			++ans;
		
		for(auto x : edge[rnow.now])
		{
			PQ.push(bfsnode(x.to, rnow.dis + x.val, x.ok));
		}
	}
	
	cout << k - ans << '\n';
}
 
int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);
    
	//freopen("azerah.in","r",stdin); 
	//freopen("azerah.out","w",stdout); 
	
	cin >> n >> m >> k;
	
	for(int i = 0; i < m; ++i)
	{
		ll a, b, c;
		cin >> a >> b >> c;
		edge[a].push_back(node(b, c, 0));
		edge[b].push_back(node(a, c, 0));
	}
	
	for(int i = 0; i < k; ++i)
	{
		ll a, b;
		cin >> a >> b;
		edge[1].push_back(node(a, b, 1));
		edge[a].push_back(node(1, b, 1));
	}
	
	bfs();	
   	
 
    return 0;
}

B - Phillip and Trains

人只能向右一步同时向上 或 向下 或不动， 然后火车向左两步，求会不会被撞。

解法：相对运动转化+二维dp，当前位置只能由三个位置转移而来，如果能转移到最右端则不会被撞

/*
    Zeolim - An AC a day keeps the bug away
*/

//pragma GCC optimize(2)
#include <bits/stdc++.h>
typedef long long ll;
typedef long double ld;
typedef std::pair<int, int> pii;
//typedef __int128 ill;
const ld PI = acos(-1.0);
const ld E = exp(1.0);
const ll INF = 0x3f3f3f3f;
const ll MOD = 1e9 + 7;
using namespace std;
const int MAXN = 4e6 + 10;

char arr[5][200];
int ok[5][200];

bool check(int x, int y)
{
	if ( arr[x][y] != '.' || arr[x][y - 1] != '.' || arr[x][y - 2] != '.')
		return false;
		
	if(arr[x][y - 3] == '.' && ok[x][y - 3])
		return true;
	
	if(x != 2)
	{
		if(arr[x + 1][y - 2] == '.' && arr[x + 1][y - 3] == '.' && ok[x + 1][y - 3])
			return true;
	}
	if(x != 0)
	{
		if(arr[x - 1][y - 2] == '.' && arr[x - 1][y - 3] == '.' && ok[x - 1][y - 3])
			return true;
	}
	return false;
}
int main()  
{   
    ios::sync_with_stdio(0);
    cin.tie(0); cout.tie(0);  
    
    int t;
    
    cin >> t;
    
    while(t--)
    {
    	memset(arr, '.', sizeof(arr));
    	memset(ok, 0, sizeof(ok));
    	
    	int n, k;
    	
    	cin >> n >> k;
    	
    	for(int i = 0; i < 3; ++i)
    	{
    		for(int j = 0; j < n; ++j)
    		{
    			cin >> arr[i][j];
    			if(arr[i][j] == 's')
    				ok[i][j] = 1, arr[i][j] = '.';
			}
		}
		
		bool flag = false;
		
		for(int j = 3; j < n + 10; j++)
		{
			for(int i = 0; i < 3; ++i)
			{
				if(check(i, j))
				{
					ok[i][j] = true;
					if(j >= n - 1)
						flag = true;
				}
			}
		}
		
//		for(int i = 0; i < 3; ++i)
//		{
//			for(int j = 0; j < n; ++j)
//			{
//				cout << ok[i][j] ;
//			}
//			cout << '\n';
//		}
		
		
		if(flag)
			cout << "YES\n";
		else
			cout << "NO\n";
	
    	
	}
    
     
    return 0;  
} 

/*
1
16 4
...AAAAA........
s.BBB....CCCCC..
.......DDDDD....
*/

C - A Mist of Florescence

 题意，构造一个50*50 以内的矩阵，包含a个A联通快，b个B联通块，c个C联通块，d个D联通块。

解法：构造4个25*25的ABCD矩阵连在一起， 然后每九宫格往里填即可。

/*
	    Zeolim - An AC a day keeps the bug away
	*/
	
	//pragma GCC optimize(2)
	#include <bits/stdc++.h>
	typedef long long ll;
	typedef long double ld;
	typedef std::pair<int, int> pii;
	//typedef __int128 ill;
	const ld PI = acos(-1.0);
	const ld E = exp(1.0);
	const ll INF = 0x3f3f3f3f;
	const ll MOD = 1e9 + 7;
	using namespace std;
	const int MAXN = 1e2 + 10;
	
	char mp[MAXN][MAXN] = {0};
	
	void init(int x, int y, char c)
	{
		for(int i = x; i < x + 25; ++i)
		{
			for(int j = y; j < y + 25; ++j)
			{
				mp[i][j] = c;
			}
		}
	}
	
	void show()
	{
		for(int i = 0; i < 50; ++i)
		{
			for(int j = 0; j < 50; ++j)
			{
				cout << mp[i][j];
			}
			cout << '\n';
		}
	}
	
	int main()  
	{   
		ios::sync_with_stdio(0);
		cin.tie(0); cout.tie(0);  
		
		int a, b, c, d;
		
		cin >> a >> b >> c >> d;
		
		init(0, 0, 'A');
		init(0, 25, 'B');
		init(25, 0, 'C');
		init(25, 25, 'D');
		
		--a, --b, --c, --d;
		
		for(int i = 1; i < 50; i += 2)
		{
			if(i == 25)
				++i;
			for(int j = 1; j < 50; j += 2)
			{
				if(j == 25)
					++j;
				if(a && mp[i][j] != 'A')
				 	--a, mp[i][j] = 'A';
				
				else if(b && mp[i][j] != 'B')
				 	--b, mp[i][j] = 'B';
				
				else if(c && mp[i][j] != 'C')
					--c, mp[i][j] = 'C';
				else if(d && mp[i][j] != 'D')
					--d, mp[i][j] = 'D';
			}
		}
		
		
		cout << "50 50\n";
		
		show();
		
	    return 0;  
	}

D - Unbearable Controversy of Being

题意：求图中菱形个数

遍历所有点能达到的长度为2的路径的到达点，map计数，加法原理记录答案。

/*
    Zeolim - An AC a day keeps the bug away
*/

//pragma GCC optimize(2)
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double ld;
typedef std::pair<int, int> pii;
#define mp(x, y) make_pair(x, y) 
//typedef __int128 ill;
const ld PI = acos(-1.0);
const ld E = exp(1.0);
const ll INF = 1e18; 
const ll MOD = 1e9 + 7;
const int MAXN = 3e3 + 10;

int n, m;

vector <int> edge[MAXN];

int ans = 0;

map <int, int> rec;
	
bitset <MAXN> used[MAXN];



void cal(int now)
{
	
	rec.clear();
	
	for(int i = 1; i <= n; ++i)
		used[i].reset();
	
	for(auto x : edge[now])
	{
		for(auto y : edge[x])
		{
			if(!used[x][y] && y != now)
			{
				ans += rec[y];
				++rec[y];
			}
		}
	}
		
	return ;
}



int main()
{ 	
	cin >> n >> m;
	
	for(int i = 0, from, to; i < m; ++i)
		cin >> from >> to, edge[from].push_back(to);
		
	for(int i = 1; i <= n; ++i)
	{
		cal(i);
	}
	
	cout << ans << '\n';
	
    return 0;
}

E - Igor In the Museum

 题意：每个.和*之间都有一副画，求点x，y所在联通块内画的总数。

思路：dfs染色记录答案输出

我用的二维映射一维＋并查集

/*
    Zeolim - An AC a day keeps the bug away
*/

//pragma GCC optimize(2)
#include <bits/stdc++.h>
typedef long long ll;
typedef long double ld;
typedef std::pair<int, int> pii;
//typedef __int128 ill;
const ld PI = acos(-1.0);
const ld E = exp(1.0);
const ll INF = 0x3f3f3f3f;
const ll MOD = 1e9 + 7;
using namespace std;
const int MAXN = 2e6 + 10;

char mp[1100][1100];
bool used[1100][1100][4];

int fa[MAXN] = {0};
int val[MAXN] = {0};

int movl[4][2] = {{0, -1}, {-1, 0}, {0, 1}, {1, 0}};

int findfa(int x)
{
	return x == fa[x] ? x : fa[x] = findfa(fa[x]);
}

int n, m, k;

int tra(int x, int y)
{
	return (x - 1) * m + y;
}

void oprt(int x, int y)
{
	for(int i = 0; i < 4; ++i)
	{
		int rx = x + movl[i][0], ry = y + movl[i][1], rp = tra(x, y);
		if(mp[rx][ry] == '*' && !used[rx][ry][i])
		{
			++val[rp];
			used[rx][ry][i] = true;
		}
	}
	
	for(int i = 0; i < 2; ++i)
	{
		int rx = x + movl[i][0], ry = y + movl[i][1], rp = tra(rx, ry), rrp = tra(x, y);
		if(mp[rx][ry] == '.')
		{
			int p = findfa(rp), q = findfa(rrp);
			if(p != q)
			{
				fa[p] = q;
				val[q] += val[p];
			}
		}
	}
}

int main()  
{   
	ios::sync_with_stdio(0);
	cin.tie(0); cout.tie(0);  

    cin >> n >> m >> k;
    
    for(int i = 0; i <= n * m + n + m + 100; ++i)
    {
    	fa[i] = i;
	}
    
    for(int i = 1; i <= n; ++i)
    {
    	for(int j = 1; j <= m; ++j)
    	{
    		cin >> mp[i][j];                    
		}
	}
	
	
	for(int i = 1; i <= n; ++i)
	{
		for(int j = 1; j <= m; ++j)
		{
			if(mp[i][j] == '.')
			{
				oprt(i, j);
			}
		}
	}
	
	
	while(k--)
	{
		int x, y;
		
		cin >> x >> y;
		
		int rp = findfa( tra(x, y) );
		
		cout << val[rp] << '\n';
	}
    
    return 0;  
}

F - The Child and Toy

 智障题，删每条边两端点最小点权之和

/*
    Zeolim - An AC a day keeps the bug away
*/

//pragma GCC optimize(2)
#include <bits/stdc++.h>
typedef long long ll;
typedef long double ld;
typedef std::pair<int, int> pii;
//typedef __int128 ill;
const ld PI = acos(-1.0);
const ld E = exp(1.0);
const ll INF = 0x3f3f3f3f;
const ll MOD = 1e9 + 7;
using namespace std;
const int MAXN = 1e6 + 10;


ll val[MAXN];

int main()  
{  
	ios::sync_with_stdio(0);
	cin.tie(0); cout.tie(0);
	
	int n, m;
	
	cin >> n >> m;
	
	for(int i = 1; i <= n; ++i)
	{
		cin >> val[i];
	}
	
	ll ans = 0;
	
	for(int i = 1; i <= m; ++i)
	{
		int p, q;
		cin >> p >> q;
		ans += min(val[p], val[q]);
	}
	
	cout << ans << '\n';
    
    return 0;  
}

G - New Year Permutation

一个矩阵，若i,j == j,i == 1则这部分有传递性可互换，求最小排列。

用并查集维护联通块后set排序+位置直接复写数组输出即可

/*
    Zeolim - An AC a day keeps the bug away
*/

//pragma GCC optimize(2)
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef double ld;
typedef std::pair<int, int> pii;
#define mp(x, y) make_pair(x, y) 
//typedef __int128 ill;
const ld PI = acos(-1.0);
const ld E = exp(1.0);
const ll INF = 1e18; 
const ll MOD = 1e9 + 7;
const int MAXN = 5e2 + 10;

int fa[MAXN];

int findfa(int x)
{
	return x == fa[x] ? x : fa[x] = findfa(fa[x]);
}

int arr[MAXN] = {0};

bitset <MAXN> ok[MAXN];

set <int> ST[MAXN], RT[MAXN];

int main()
{ 	
	int n;
	
	cin >> n;
	
	for(int i = 1; i <= n; ++i)
		cin >> arr[i];
		
	for(int i = 1; i <= n; ++i)
	{
		fa[i] = i;
		for(int j = 1; j <= n; ++j)
		{
			char x;
			
			cin >> x;
			
			ok[i][j] = x == '1';
		}
	}
	
	for(int i = 1; i <= n; ++i)
	{
		for(int j = 1; j <= n; ++j)
		{
			if(ok[i][j] && ok[j][i])
			{
				int p = findfa(i), q = findfa(j);
				
				if(p != q)
					fa[p] = q;
			}
		}
	}
	
	for(int i = 1; i <= n; ++i)
	{
		int p = findfa(i);
		ST[p].insert(arr[i]);
		RT[p].insert(i);
	}
	
	for(int i = 1; i <= n; ++i)
	{
		auto r = RT[i].begin();
		for(auto x : ST[i])
		{
			arr[ *r ] = x;
			++r;
		}
	}
	
	for(int i = 1; i <= n; ++i)
		cout << arr[i] << ' ';
	
	
	
	
	
    return 0;
}

H - Alyona and the Tree

 规定1为根节点，若存在dis（u，v） > val(u)则称u 伤心，问需要删多少点才让整棵树不伤心

从根dfs统计不伤心的点，加上一点的树上dp （最大路径和）即可

/*
    Zeolim - An AC a day keeps the bug away
*/

//pragma GCC optimize(2)
#include <bits/stdc++.h>
typedef long long ll;
typedef long double ld;
typedef std::pair<int, int> pii;
//typedef __int128 ill;
const ld PI = acos(-1.0);
const ld E = exp(1.0);
const ll INF = 0x3f3f3f3f;
const ll MOD = 1e9 + 7;
using namespace std;
const int MAXN = 1e6 + 10;

ll val[MAXN] = {0};
bool used[MAXN] = {0};

struct node
{
	ll to, val;
	node(){}
	node(int x, int y)
	{
		to = x;
		val = y;
	} 
};

vector <node> edge[MAXN];


int n, k;

void dfs(ll now, ll sum)
{
	if(sum > val[now])
		return;
		
	used[now] = true;
	
	for(int i = 0; i < edge[now].size(); ++i)
	{
		if(!used[edge[now][i].to])
			dfs(edge[now][i].to, max(sum + edge[now][i].val, edge[now][i].val));
	}
}


int main()  
{   
    cin >> n;
    
    for(int i = 1; i <= n; ++i)
    	cin >> val[i];
    	
    for(int i = 2; i <= n; ++i)
    {
    	int to, val;
    	cin >> to >> val;
    	edge[i].push_back(node(to, val));
    	edge[to].push_back(node(i, val));
	}
	
	dfs(1, 0);
	
	int ans = n;
	
	for(int i = 1; i <= n; ++i)
	{
		if(used[i])
			--ans;
	}
	
	cout << ans << '\n';
	
    return 0;  
}

 

Zeolim
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
CCPC-Wannafly Summer Camp #1——A——Birthday（最小费用流）
weixin_30474613的博客
08-02 110
时间限制: 1 Sec内存限制: 256 MB 题目描述 恬恬的生日临近了。宇扬给她准备了一个大蛋糕。 正如往常一样，宇扬在蛋糕上插了n支蜡烛，并把蛋糕分为m个区域。因为某种原因，他必须把第i根蜡烛插在第ai个区域或第bi个区域。区域之间是不相交的。宇扬在一个区域内同时摆放x支蜡烛就要花费x2的时间。宇扬布置蛋糕所用的总时间是他在每个区域花的时间的和。 ...
CCPC-Wannafly Summer Camp 2019
git1314的博客
07-23 561
2019暑假CCPC-Camp在东北大学-秦皇岛分校举行 训练营是针对CCPC区域赛银牌及以下的，每天可以在comet上观看直播, 在Vjudge上做题 早上直播时间是早上8：30 - 11：30 晚上讲题 19：00~ 21： 00 直播地址： https://cometoj.com/liveDetail/100000 直播内容： Day 1： Day1-专题-图论（洪华敦） Day2...
CCPC-WannaFly-Camp #1ABirthday
点滴
08-03 490
A: Birthday 题目描述： 题目入口 恬恬的生日临近了。宇扬给她准备了一个大蛋糕。 正如往常一样，宇扬在蛋糕上插了n支蜡烛，并把蛋糕分为m个区域。因为某种原因，他必须把第i根蜡烛插在第ai个区域或第bi个区域。区域之间是不相交的。宇扬在一个区域内同时摆放x支蜡烛就要花费x2的时间。宇扬布置蛋糕所用的总时间是他在每个区域花的时间的和。 宇扬想快些见到恬恬，你能告诉他布置蛋糕最少需要...
Wannafly 2018年全国多校算法寒假训练营练习比赛（第四场） G 老子的意大利炮昵
包子不卖包子
03-12 1813
链接题目描述 自攻打过太原县城以后，李云龙这意大利炮就使用的越发的顺手了，指哪打哪也是绝不含糊，于是小野队长开始疯狂打击独立团炮兵营，为了锻炼士兵移动意大利炮的能力，李团长开始给炮兵营进行特训，众(wo)所(xia)周(bian)知(de)，意大利炮可由炮管，车轮，炮弹三部分组成，现在李团长在洋村设立阵地，分别把炮管，车轮，炮弹放在三个不同的地方，每一部分的重量不同，所以运输的速度也不相同。团长...
CCPC-Online-2023-题解.pdf
08-20
CCPC-Online-2023-题解.pdf
CCPC-PAS.exe
10-31
CCPC-PAS.exe
PMTS-CCPC-TLQ7.2安装方法.docx
04-01
TLQ7.2在系统环境下的安装方法，希望可以帮助到大家
2019第五届CCPC河南省赛
10-28
2019第五届CCPC省赛 word 文档，找了很久一直没找到，这是HUEL—ACM实验室20级杨宇航同学自己扒的，感谢学弟
2019年USSTSIW ICPC &amp; CCPC暑期集训队练习赛8-Problems1
08-03
第一行输入正整数n(1 )，表示马儿的数量 第一行输入一个整数T(1 ) 第一行，A与B在二进制表示下的长度n与m，
Wannafly summer camp
紫芝的博客
09-28 524
2053: Birthday 样例输入 3 3 1 2 1 2 1 2 样例输出 5 分析： 考虑费用流时把每个part拆成n个点，选择第i个点的代表为放置i块蛋糕和(i - 1)块蛋糕的时间差，这个时间差是递增的，因此在费用流的过程中必定会从小到大选择 具体建图：左边n个点代表n个蛋糕，右边m * n个点代表m个part,每个part拆成n个点。源点向每个左边的点连一条流...
CCPC-WannaFly-Camp Growth(离散化DP)
mlm5678的博客
08-16 395
问题 D: Growth 时间限制: 1 Sec 内存限制: 256 MB 弱弱有两个属性a和b，这两个属性初始的时候均为0，每一天他可以通过努力，让a涨1点或b涨1点。 为了激励弱弱努力学习，我们共有n种奖励，第i种奖励有xi，yi，zi三种属性，若a ≥ xi且b ≥ yi，则弱弱在接下来的每一天都可以得到zi的分数。 问m天以后弱弱最多能得到多少分数。 输入 第一行一个两个整数...
CCPC-Wannafly Camp #2 J Princess Principal 【离线+栈】
beckyUp的博客
08-06 480
分析：这个题目，我们离线处理所有的查询区间，将所有区间按照右端点排序，然后通过栈去匹配括号，左括号直接入栈，右括号的话，如果匹配上了，就出栈，如果没有匹配上了，就留在栈中，当我们扫描到第i个的时候，对于右端点为i的询问，我们判断它的左区间是否比栈顶元素要小，如果小的话，就不能够匹配上了，如果大的话 我们会发现，我们通过这样处理可以保证查询的右端点在右区间，但不能保证询问的左端点，所以我们预处理...
CCPC-WannaFly-Camp #5A矩阵乘法 【分块】
点滴
08-08 795
1082: 矩阵乘法 时间限制: 2 Sec 内存限制: 128 MB 提交: 97 解决: 6 [提交][状态][讨论版][命题人:admin] 题目描述 深度学习算法很大程度上基于矩阵运算。例如神经网络中的全连接本质上是一个矩阵乘法，而卷积运算也通常是用矩阵乘法来实现的。有一些科研工作者为了让神经网络的计算更快捷，提出了二值化网络的方法，就是将网络权重压缩成只用两种值表示的形式，...
CCPC-Wannafly Summer Camp #1（部分解题报告）
lived的博客
08-06 1412
A:Birthday 时间限制: 1 Sec  内存限制: 256 MB 题目描述 恬恬的生日临近了。宇扬给她准备了一个大蛋糕。 正如往常一样，宇扬在蛋糕上插了n支蜡烛，并把蛋糕分为m个区域。因为某种原因，他必须把第i根蜡烛插在第ai个区域或第bi个区域。区域之间是不相交的。宇扬在一个区域内同时摆放x支蜡烛就要花费x2的时间。宇扬布置蛋糕所用的总时间是他在每个区域花的时间的和。 宇扬想快...
CCPC-Wannafly Camp #4（部分解题报告）
lived的博客
08-08 990
B: 电音之王 时间限制: 7 Sec  内存限制: 1024 MB 第一次听说快速乘法，记录一下，用的大佬的板子 #include&amp;lt;bits/stdc++.h&amp;gt; #define LL long long using namespace std; LL multi(LL x,LL y,LL mod){ LL tmp = (x * y - (LL)((long do...
CCPC-WannaFly-Camp #4 L数论之神
点滴
08-05 1502
数论之神 12.1 题目描述 终于活成了自己讨厌的样子。 这是她们都还没长大的时候发生的故事。那个时候，栗子米也不需要为了所谓的爱情苦恼。 她们可以在夏日的午后，花大把的时间去研究生活中一些琐碎而有趣的事情，比如数论。 有一天西柚柚问了栗子米一个题，她想知道 ⌊n/1⌋, ⌊n/2⌋, … , ⌊n/n⌋ 中有多少不同的数这些不同的数字里面第 k 大的是多少。 12.2 输入格式 ...
CCPC-Wannafly Camp #2 （部分题解）
lived的博客
08-06 748
L: New Game! 题目描述： Eagle Jump公司正在开发一款新的游戏。泷本一二三作为其员工，获得了提前试玩的机会。现在她正在试图通过一个迷宫。 这个迷宫有一些特点。为了方便描述，我们对这个迷宫建立平面直角坐标系。迷宫中有两条平行直线 L\_1:Ax+By+C\_1=0L1​:Ax+By+C1​=0, L\_2:Ax+By+C\_2=0L2​:Ax+By+C2​=0，还有 nn ...
CCPC-Wannafly Summer Camp 2019 Day1 (无 I 题)
Whyckck的博客
08-02 232
比赛链接：https://vjudge.net/contest/312902#overview 目录 A - Jzzhu and Cities B - Phillip and Trains C - A Mist of Florescence D - Unbearable Controversy of Being E - Igor In the Museum F - The Chi...
2017-CCPC-FINAL
最新发布
10-04
2017-CCPC-FINAL是指2017年CCPC全国大学生程序设计竞赛的决赛。决赛于2017年12月3日举行，涉及多个问题，包括问题A：狗和笼子，问题G：Alice的邮票和问题H：等距离等。在问题A中，Jerry有N只狗和N个笼子，他需要将...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值