ZOJ Monthly, June 2014部分题解

最新推荐文章于 2021-06-19 21:18:15 发布
原创 最新推荐文章于 2021-06-19 21:18:15 发布 · 799 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

感觉挺不错的一套题，写下部分题目的题解

 

ZOJ 3789： Gears

题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3789

 

题意：有N个齿轮，齿轮间只有旋转方向相反才能连接，给出四个操作

L X Y ：将齿轮X, Y连接，如果它们已经有已属集合，那集合也要合并

D X：拆掉齿轮X，且X所属集合不会断裂

Q X Y：询问X，Y的旋转方向是否相同             

S X：询问X所在集合有多少个齿轮

 

思路：并查集，维护当前点到根节点的距离及当前点集合的结点个数，方向是否相同可以通过到根节点的距离之差的奇偶性来判断，对于删除结点操作，可以将该点映射到新的结点上，在合并X，Y时要注意更新距离数组

 

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
#include <utility>
#include <cmath>
#include <queue>
#include <set>
#include <map>
#include <climits>
#include <functional>
#include <deque>
#include <ctime>

#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
#pragma comment(linker, "/STACK:102400000,102400000")

using namespace std;

const int maxn = 600010;

int fa[maxn], dis[maxn], num[maxn], p[maxn];

void init()
{
	for (int i = 0; i < maxn; i++)
	{
		fa[i] = i;
		dis[i] = 0;
		num[i] = 1;
		p[i] = i;
	}
}

int Find(int x)
{
	if (x == fa[x]) return x;

	int fff = Find(fa[x]);
	dis[x] += dis[fa[x]];
	return fa[x] = fff;
}

int main()
{
	int n, m;
	while (~scanf("%d%d", &n, &m))
	{
		init();

		int cnt = n;
		for (int i = 0; i < m; i++)
		{
			char c[5];
			scanf("%s", c);
			if (c[0] == 'L')
			{
				int u, v;
				scanf("%d%d", &u, &v);

				u = p[u], v = p[v];
				int fu = Find(u), fv = Find(v);
				if (fu == fv) continue;

				fa[fu] = fv;
				num[fv] += num[fu];
				dis[fu] = dis[u] + dis[v] + 1;
			}
			if (c[0] == 'D')
			{
				int u;
				scanf("%d", &u);

				int pu = p[u];
				int fu = Find(pu);
				num[fu]--;
				p[u] = ++cnt;
			}
			if (c[0] == 'Q')
			{
				int u, v;
				scanf("%d%d", &u, &v);

				u = p[u], v = p[v];
				int fu = Find(u), fv = Find(v);
				if (fu != fv)
					puts("Unknown");
				else
				{
					if (abs(dis[u] - dis[v]) % 2 == 0)
						puts("Same");
					else
						puts("Different");
				}
			}
			if (c[0] == 'S')
			{
				int u;
				scanf("%d", &u);

				u = p[u];
				printf("%d\n", num[Find(u)]);
			}
		}
	}
	return 0;
}

 

 

ZOJ 3790：Consecutive Blocks

题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3790

 

题意：给一个长度为N的序列，你可以从该序列中任意删除K个数，问同一个数字最多能连续多长

 

思路：先离散化处理，然后对于离散化后的每个数字固定起点，枚举终点进行二分判断，找出最长的结果

 

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
#include <utility>
#include <cmath>
#include <queue>
#include <set>
#include <map>
#include <climits>
#include <functional>
#include <deque>
#include <ctime>

#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
#pragma comment(linker, "/STACK:102400000,102400000")

using namespace std;

const int maxn = 100010;

map <int, int> ma;
vector <int> v[maxn];

int main()
{
	int n, k;
	while (~scanf("%d%d", &n, &k))
	{
		ma.clear();
		for (int i = 0; i <= n; i++)
			v[i].clear();

		int cnt = 0;
		for (int i = 0; i < n; i++)
		{
			int x;
			scanf("%d", &x);
			int p = ma[x];
			if (!p) ma[x] = ++cnt;
			v[ma[x]].push_back(i);
		}

		int ans = 0;
		for (int i = 1; i <= cnt; i++)
		{
			int si = v[i].size();
			for (int j = 0; j < si; j++)
			{
				int l = -1, r = j;
				while (r - l > 1)
				{
					int mid = (l + r) >> 1;

					int sr = v[i][j], sl = v[i][mid];
					if (sr - sl - (j - mid) > k)
						l = mid;
					else
						r = mid, ans = max(ans, j - mid + 1);
				}
				ans = max(ans, j - r + 1);
			}
		}
		cout << ans << endl;
	}
	return 0;
}

 

 

 

ZOJ 3791：An Easy Game

题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3791

 

题意：给出两个01字符串s1,s2，每次能且只能改变s1上m个位置的字符，问k次之后有多少种方法让s1变作s2

 

思路：dp[i][j]表示i次之后两串有j个字符不同，经过一次操作后可以将j个字符中的的t个位置变相同，剩余n - j个位置中m - t个位置变不同，故而有转移方程：dp[i + 1][j - t + m - t] += dp[i][j] * C(j, t) * C(n - j, m - t)，要注意t的枚举范围需满足j - t + m - t <= n

 

 

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
#include <utility>
#include <cmath>
#include <queue>
#include <set>
#include <map>
#include <climits>
#include <functional>
#include <deque>
#include <ctime>

#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
#pragma comment(linker, "/STACK:102400000,102400000")

using namespace std;

const int maxn = 200;
const int mod = 1e9 + 9;

typedef long long ll;

ll dp[maxn][maxn], c[maxn][maxn];
char s[maxn], ss[maxn];

void init()
{
	c[0][0] = 1;
	for (int i = 1; i <= 100; i++)
	{
		c[i][0] = 1;
		for (int j = 1; j <= i; j++)
			c[i][j] = (c[i - 1][j - 1] + c[i - 1][j]) % mod;
	}
}

int main()
{
	init();
	int n, m, k;
	while (~scanf("%d%d%d", &n, &k, &m))
	{
		memset(dp, 0, sizeof(dp));
		scanf("%s", s);
		scanf("%s", ss);

		int num = 0;
		for (int i = 0; i < n; i++)
			if (s[i] != ss[i]) num++;

		dp[0][num] = 1;
		for (int i = 0; i < k; i++)
			for (int j = 0; j <= n; j++)
			{
				if (dp[i][j] == 0) continue;

				for (int t = max((j + m - n) / 2, 0); t <= j && t <= m; t++)
					dp[i + 1][j - t + m - t] = (dp[i + 1][j - t + m - t] + dp[i][j] * c[j][t] % mod * c[n - j][m - t] % mod) % mod;
			}

		cout << dp[k][0] << endl;
	}
	return 0;
}

 

 

 

 

ZOJ 3792：Romantic Value

题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3792

 

题意：给一张无向图，给出起点和终点，要删除一些边使起点到终点不连通，在删除边权值最小的情况下保证删除边的数目最少，求剩余边权值和 / 删除边数的这一比值

 

思路：可以构造每条边的边权为w *  maxn + 1，这样就不会出现多种最小割的方案了，注意maxn要较大使得边数不会影响网络流的流向，最终跑出来的结果ans / maxn为最小割，ans % maxn为删除边数

也可以在原图跑完最大流的基础上，找出那些满流的边将其流量改为1，其余边流量改为INF，再跑一次最大流也可以找出删除的最少边数

 

 

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
#include <utility>
#include <cmath>
#include <queue>
#include <set>
#include <map>
#include <climits>
#include <functional>
#include <deque>
#include <ctime>

#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
#pragma comment(linker, "/STACK:102400000,102400000")

using namespace std;

const int MAXN = 1010;
const int MAXM = 50010;
const int INF = 0x3f3f3f3f;

typedef long long ll;

struct Edge
{
	int to, next, cap, flow;
} edge[MAXM];

int tol;
int head[MAXN];
int gap[MAXN], dep[MAXN], cur[MAXN];

void init()
{
	tol = 0;
	memset(head, -1, sizeof(head));
}

void addedge(int u, int v, int w, int rw = 0)
{
	edge[tol].to = v;
	edge[tol].cap = w;
	edge[tol].flow = 0;
	edge[tol].next = head[u];
	head[u] = tol++;
	edge[tol].to = u;
	edge[tol].cap = rw;
	edge[tol].flow = 0;
	edge[tol].next = head[v];
	head[v] = tol++;
}

int Q[MAXN];

void BFS(int start, int end)
{
	memset(dep, -1, sizeof(dep));
	memset(gap, 0, sizeof(gap));
	gap[0] = 1;
	int front = 0, rear = 0;
	dep[end] = 0;
	Q[rear++] = end;
	while (front != rear)
	{
		int u = Q[front++];
		for (int i = head[u]; i != -1; i = edge[i].next)
		{
			int v = edge[i].to;
			if (dep[v] != -1)continue;
			Q[rear++] = v;
			dep[v] = dep[u] + 1;
			gap[dep[v]]++;
		}
	}
}

int S[MAXN];

int sap(int start, int end, int N)
{
	BFS(start, end);
	memcpy(cur, head, sizeof(head));
	int top = 0;
	int u = start;
	int ans = 0;
	while (dep[start] < N)
	{
		if (u == end)
		{
			int Min = INF;
			int inser;
			for (int i = 0; i < top; i++)
				if (Min > edge[S[i]].cap - edge[S[i]].flow)
				{
					Min = edge[S[i]].cap - edge[S[i]].flow;
					inser = i;
				}
			for (int i = 0; i < top; i++)
			{
				edge[S[i]].flow += Min;
				edge[S[i] ^ 1].flow -= Min;
			}
			ans += Min;
			top = inser;
			u = edge[S[top] ^ 1].to;
			continue;
		}
		bool flag = false;
		int v;
		for (int i = cur[u]; i != -1; i = edge[i].next)
		{
			v = edge[i].to;
			if (edge[i].cap - edge[i].flow && dep[v] + 1 == dep[u])
			{
				flag = true;
				cur[u] = i;
				break;
			}
		}
		if (flag)
		{
			S[top++] = cur[u];
			u = v;
			continue;
		}
		int Min = N;

		for (int i = head[u]; i != -1; i = edge[i].next)
			if (edge[i].cap - edge[i].flow && dep[edge[i].to] < Min)
			{
				Min = dep[edge[i].to];
				cur[u] = i;
			}
		gap[dep[u]]--;
		if (!gap[dep[u]])return ans;
		dep[u] = Min + 1;
		gap[dep[u]]++;
		if (u != start)u = edge[S[--top] ^ 1].to;
	}
	return ans;
}

int main()
{
	int tt;
	cin >> tt;
	while (tt--)
	{
		init();
		int n, m, p, q;
		cin >> n >> m >> p >> q;

		int sum = 0;
		for (int i = 0; i < m; i++)
		{
			int u, v, w;
			scanf("%d%d%d", &u, &v, &w);
			sum += w;
			addedge(u, v, w * MAXN + 1);
			addedge(v, u, w * MAXN + 1);
		}

		int ans = sap(p, q, n + 1);
		if (ans == 0)
			puts("Inf");
		else
			printf("%.2f\n", 1.0 * (sum - ans / MAXN) / (ans % MAXN));
	}
	return 0;
}

 

 

 

ZOJ 3793：First Digit

题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3793

 

题意：本福特定律的介绍

 

思路：数字1是满足那个概率范围的，所以输出1即可

 

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
#include <utility>
#include <cmath>
#include <queue>
#include <set>
#include <map>
#include <climits>
#include <functional>
#include <deque>
#include <ctime>

#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
#pragma comment(linker, "/STACK:102400000,102400000")

using namespace std;

const int maxn = 100010;

typedef long long ll;

int a[maxn];

int main()
{
	int t;
	cin >> t;
	while (t--)
	{
		int b, e;
		cin >> b >> e;
		cout << 1 << endl;
	}
	return 0;
}

 

 

 

ZOJ  3794：Greedy Driver

题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3794

 

题意：一个司机要从1走到N，他可以在任意有加油站的地点加油，走每条道路需要消耗相应的油量，有些城市可以通过卖油赚钱，但只能卖一次油，如果司机不能走到N，输出-1，如果能走到输出最多能赚多少钱

 

思路：从起点跑一次spfa算出到每个点最多能剩多少油，再从起点反向跑一次spfa算出每个点到终点的最短距离，即最少需要多少油到终点，然后枚举每个可以卖油的城市更新答案，在跑spfa的过程中要注意对加油站的处理

 

 

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
#include <utility>
#include <cmath>
#include <queue>
#include <set>
#include <map>
#include <climits>
#include <functional>
#include <deque>
#include <ctime>

#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
#pragma comment(linker, "/STACK:102400000,102400000")

using namespace std;

const int maxn = 1010;
const int maxm = 100010;
const int inf = 0x3f3f3f3f;

int n, m, c;

int cnt, head[maxn];
int f[maxn], vis[maxn], dis[maxn];
int p[maxn], q[maxn];

struct edge
{
	int to, w, nxt, id;
} e[maxm << 1];

void init()
{
	cnt = 0;
	memset(head, -1, sizeof(head));
}

void add(int u, int v, int w, int id)
{
	e[cnt].to = v;
	e[cnt].w = w;
	e[cnt].id = id;
	e[cnt].nxt = head[u];
	head[u] = cnt++;
}

void spfa(int s)
{
	memset(vis, 0, sizeof(vis));
	memset(f, -1, sizeof(f));
	queue <int> que;

	que.push(s);
	f[s] = c, vis[s] = 1;
	while (!que.empty())
	{
		int u = que.front();
		que.pop();
		vis[u] = 0;

		for (int i = head[u]; ~i; i = e[i].nxt)
		{
			if (e[i].id == 1) continue;

			int v = e[i].to;
			if (f[u] >= e[i].w)
			{
				int tmp = f[u] - e[i].w;
				if (p[v]) tmp = c;

				if (tmp > f[v])
				{
					f[v] = tmp;
					if (!vis[v])
					{
						vis[v] = 1;
						que.push(v);
					}
				}
			}
		}
	}
}

void rspfa(int s)
{
	memset(vis, 0, sizeof(vis));
	memset(dis, inf, sizeof(dis));
	queue <int> que;

	que.push(s);
	dis[s] = 0, vis[s] = 1;
	while (!que.empty())
	{
		int u = que.front();
		que.pop();
		vis[u] = 0;

		for (int i = head[u]; ~i; i = e[i].nxt)
		{
			if (e[i].id == 0) continue;

			int v = e[i].to;
			if (dis[v] > dis[u] + e[i].w)
			{
				dis[v] = dis[u] + e[i].w;
				if (p[v]) dis[v] = 0;

				if (!vis[v])
				{
					vis[v] = 1;
					que.push(v);
				}
			}
		}
	}
}

int main()
{
	while (~scanf("%d%d%d", &n, &m, &c))
	{
		init();

		for (int i = 0; i < m; i++)
		{
			int u, v, w;
			scanf("%d%d%d", &u, &v, &w);
			add(u, v, w, 0);
			add(v, u, w, 1);
		}

		memset(p, 0, sizeof(p));
		memset(q, 0, sizeof(q));

		int P, Q;
		scanf("%d", &P);
		while (P--)
		{
			int x;
			scanf("%d", &x);
			p[x] = 1;
		}

		scanf("%d", &Q);
		while (Q--)
		{
			int x, v;
			scanf("%d%d", &x, &v);
			q[x] = v;
		}

		spfa(1);

		if (f[n] == -1)
		{
			puts("-1");
			continue;
		}

		rspfa(n);

		// for (int i = 1; i <= n; i++)
		// 	printf("************%d %d\n", f[i], dis[i]);

		int ans = 0;
		for (int i = 1; i <= n; i++)
		{
			if (q[i] && f[i] >= dis[i])
				ans = max(ans, (f[i] - dis[i]) * q[i]);
		}

		cout << ans << endl;
	}
	return 0;
}

 

 

 

ZOJ 3795：Grouping

题目链接：http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=3795

 

题意：给定N个点M条单向边，问最少需要分多少个集合，使得集合内的点都不能达到其他点

 

思路：对于强连通分量内的点肯定不能在一个集合，另外该分量所在的那一条路径上的点也不能在同一个集合，故缩点后处理出一条点权和最大的路径即是答案

 

 

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
#include <utility>
#include <cmath>
#include <queue>
#include <set>
#include <map>
#include <climits>
#include <functional>
#include <deque>
#include <ctime>

#define lson l, mid, rt << 1
#define rson mid + 1, r, rt << 1 | 1
#pragma comment(linker, "/STACK:102400000,102400000")

using namespace std;

const int maxn = 101000;
const int maxm = 300010;
const int inf = 0x3f3f3f3f;

int cnt, head[maxn];

int low[maxn], dfn[maxn], sta[maxn], bel[maxn];
int idx, top, scc;
bool insta[maxn];
int num[maxn];

struct edge
{
	int to, w, nxt;
} e[maxm];

void init()
{
	cnt = 0;
	memset(head, -1, sizeof(head));
}

void add(int u, int v)
{
	e[cnt].to = v;
	e[cnt].nxt = head[u];
	head[u] = cnt++;
}

void tarjan(int u)
{
	int v;
	low[u] = dfn[u] = ++idx;
	sta[top++] = u;
	insta[u] = true;

	for (int i = head[u]; ~i; i = e[i].nxt)
	{
		int v = e[i].to;

		if (!dfn[v])
		{
			tarjan(v);
			if (low[u] > low[v])
				low[u] = low[v];
		}
		else if (insta[v] && low[u] > dfn[v])
			low[u] = dfn[v];
	}
	if (low[u] == dfn[u])
	{
		scc++;
		do
		{
			v = sta[--top];
			insta[v] = false;
			bel[v] = scc;
			num[scc]++;
		} while (v != u);
	}
}

void solve(int n)
{
	idx = scc = top = 0;
	memset(dfn, 0, sizeof(dfn));
	memset(insta, 0, sizeof(insta));
	memset(num, 0, sizeof(num));
	for (int i = 1; i <= n; i++)
		if (!dfn[i])
			tarjan(i);
}

vector <int> g[maxn];
int dp[maxn];

int dfs(int u)
{
	if (dp[u] != -1) return dp[u];

	int res = 0;
	for (int i = 0; i < g[u].size(); i++)
	{
		int v = g[u][i];
		res = max(res, dfs(v));
	}
	dp[u] = res + num[u];
	return dp[u];
}

int main()
{
	int n, m;
	while (~scanf("%d%d", &n, &m))
	{
		init();

		for (int i = 0; i < m; i++)
		{
			int u, v;
			scanf("%d%d", &u, &v);
			add(u, v);
		}

		solve(n);

		memset(dp, -1, sizeof(dp));
		for (int i = 0; i <= scc; i++)
			g[i].clear();

		for (int u = 1; u <= n; u++)
		{
			for (int i = head[u]; ~i; i = e[i].nxt)
			{
				int v = e[i].to;
				if (bel[u] != bel[v])
					g[bel[u]].push_back(bel[v]);
			}
		}

		// for (int i = 1; i <= scc; i++)
		// 	for (int j = 0; j < g[i].size(); j++)
		// 		printf("********** %d\n", g[i][j]);

		int ans = 0;
		for (int i = 1; i <= scc; i++)
			ans = max(ans, dfs(i));
		cout << ans << endl;
	}
	return 0;
}

 

 

 

 

 

 

 

 

 

ZOJ 3659 Conquer a New Region（12年长春site E）
窝不是爱酱,喵~~~~
10-16 4072
转载请注明出处，谢谢http://blog.youkuaiyun.com/acm_cxlove/article/details/7854526       by---cxlove  题目：给出一棵树，找出一个点，求出所有点到这个点的权值和最大，权值为路径上所有边权的最小值。 http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemCode=365
ZOJ解题报告ZOJ解题报告
08-02
ZOJ解题报告ZOJ解题报告ZOJ解题报告ZOJ解题报告
ZOJ Monthly, June 2014 F - First Digit
acm_1361677193的专栏
08-03 841
F - First Digit Time Limit:2000MS     Memory Limit:65536KB     64bit IO Format:%lld & %llu Submit Status Description Benford's Law, also called the First-Digit Law, refers to the frequ
ZOJ Monthly, June 2014 解题报告
randygx的专栏
06-01 1419
A.Another Recurrence Sequence B.Gears 题目大意：有n个齿轮，一开始各自为一组，之后进行m次操作，包括以下4种类型： 1.合并两组齿轮，合并的两个应该反向旋转 2.把某个齿轮从所在组删除，自为一组，但不影响同组其它齿轮的状态与关系 3.询问两个齿轮是同向、反向或无关系(即不在同一组) 4.询问某个齿轮所在组的齿轮总数 分析：
ZOJ 2284 题解
weixin_30569033的博客
02-05 131
题目链接：http://acm.zju.edu.cn/show_problem.php?pid=2284 序列题又出现了，题目比较有意思。 意思大概是这样的，给出一个数字n，在1,2,3,4......n的这些数字中找出 组合的个数，要求这些组合的共同点是它的inversion number是k，一个 inversion number的意思就是1<=i<j...
ZOJ月赛 题解 (ZOJ Monthly, August 2014)
01-22
**ZOJ月赛题解 (ZOJ Monthly, August 2014)** ZOJ（Zhejiang Online Judge）是中国著名的在线编程竞赛平台之一，它为程序员和学生提供了丰富的算法练习和比赛机会。2014年8月的ZOJ月赛是一场面向广大编程爱好者的...
acm.tar.gz_zoj_zoj题解_题目分类
09-21
这个名为“acm.tar.gz”的压缩包文件，内含的“acm.chm”文件，正是浙江大学ZOJ题解的一部分，它以源码形式呈现了各类题目的解决方案，旨在帮助学习者深入理解算法和编程技巧。 这份题解的独特之处在于其按照题目...
2014年8月ZOJ月赛题解及排名分析
【知识点】 1. OJ平台介绍 OJ（Online Judge）是在线评测系统的简称，它为程序员提供了一个...文件名称列表中的“20141007(ZOJ Monthly, August 2014)”表明了资源对应的具体比赛日期，方便用户快速找到所需资料。
浙江大学ZOJ源码题解 - 题目分类详细解析
综上所述，这个压缩包文件"acm.tar.gz_zoj_zoj题解_题目分类"包含了针对ZOJ平台上的ACM题目进行分类整理的题解资源。学习者可以根据这些题解学习编程和算法，通过练习不同难度和类型的题目来提高自己的编程能力。" ...
ZOJ 700题源代码解析与题解
6. **题解的组织和结构**：一个优秀的题解通常包括问题描述、解题思路、详细代码以及代码解释等部分。有时还会附带优化建议和相关扩展知识。 ### 标签知识点：ZOJ 题解 7. **标签的使用**：在文档管理系统或编程...
ZOJ题解集合-截至2835
12-02
ZOJ题解集合-截至2835。共1244个文件，C/C++，有重复
ZOJ 1476 题解
weixin_30342209的博客
02-05 147
代码1#include<iostream>2#include<map>3usingnamespacestd;45intmain()6{7map<int,int>m;8ints;9intd;10intres;11intt;1213while(1)14{15scanf("%d%d",&a...
ZOJ 3369题解
Twilightuse93的专栏
07-27 786
题目连接;http://acm.hust.edu.cn/vjudge/contest/view.action?cid=26405#problem/H 本题开始用的递归，超时了，要用队列。 AC代码： #include #include #include using namespace std; struct p { int hp; int sth; i
zoj 1871 steps 题解（数学）
li1004133206的专栏
09-08 509
#数论第一练# 题目链接：http://acm.hust.edu.cn/vjudge/contest/view.action?cid=86703#problem/A 题意：给定两个数a，b，问最少执行多少步操作能从a变到b，操作是：每一步可以比前一个数字加一，或者不加，或者减一，必须保证第一步和最后一步都是加1或者减1。 思路：基本是个找规律题，多写几组容易发现，存在两个临界点，一个是前n项
ZOJ - 2316 超详细的题解
BigZong
04-08 1046
Let us consider undirected graph G =which has N vertices and M edges. Incidence matrix of this graph is N * M matrix A = {aij}, such that aijis 1 if i-th vertex is one of the ends of j-th edge and...
zoj1002题解，递归枚举
Flarep的博客
05-23 934
zoj1002 题目大意：就是在图上放blockhouse，使得每一行每一列只有一个的基础上加上了墙，有墙'X'的不同侧可以各自放； dfs枚举每一个棋子就ok，我觉得我这份代码还是比较好理解的。 写的时候坑在for了当前行之后没进行下一行dfs。 #include #include #include #include #include #include #include
关于zoj2451的题解的思考
ChaoyingL的博客
06-19 803
zoj2451个人思考
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值