2019年陕西省大学生程序设计竞赛 补题记录

最新推荐文章于 2024-10-15 19:28:18 发布
最新推荐文章于 2024-10-15 19:28:18 发布
阅读量1k 收藏 14
点赞数 24
分类专栏： xcpc题解 文章标签： 深度优先 算法 图论
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/dhxbshbdjzxy/article/details/141034934
版权

文章目录

B - Grid with Arrows（简单图论）

  • 把二维平面转化成一维的点，每个位置的箭头和数字表示一条有向边
  • 从入度为 0 的地方开始 dfs，再判断是不是所有点都遍历过了
  • 如果没有入度为 0 的点，说明所有点都在环上，但是不一定都在同一个环上，所以随便选一个点dfs一下，看看能不能经过所有点
#include <bits/stdc++.h>

using namespace std;

#define int long long
#define double long double
using i64 = long long;

typedef pair<int, int> PII;
typedef pair<int, char> PIC;
typedef pair<double, double> PDD;
typedef pair<int, PII> PIII;
typedef pair<int, pair<int, bool>> PIIB;

const int N = 1e6 + 10;
const int maxn = 1e6;
const int mod = 1e9 + 7;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;

void solve()
{
	int n, m; cin >> n >> m;
	vector<string> way(n + 1);
	vector<int> g(n * m + 10);
	for (int i = 1; i <= n; i ++ )
	{
		cin >> way[i];
		way[i] = " " + way[i];
	}
	auto getver = [&](int x, int y)
	{
		return (x - 1) * m + y;
	};
	vector<int> ind(n * m + 10);
	for (int i = 1; i <= n; i ++ )
	{
		for (int j = 1; j <= m; j ++ )
		{
			int x; cin >> x;
			int ver = getver(i, j);
			int nv = 0;
			if (way[i][j] == 'u' && i - x > 0) nv = getver(i - x, j);
			else if (way[i][j] == 'd' && i + x <= n) nv = getver(i + x, j);
			else if (way[i][j] == 'l' && j - x > 0) nv = getver(i, j - x);
			else if (way[i][j] == 'r' && j + x <= m)  nv = getver(i, j + x);
			g[ver] = nv;
			if (nv != 0) ind[nv] ++ ;
		}
	}
	bool flag = false;
	vector<bool> st(n * m + 1);
	function<void(int)> dfs = [&](int u)
	{
		int nxt = g[u];
		if (st[nxt] || nxt == 0) return;
		st[nxt] = true;
		dfs(nxt);
	};
	for (int i = 1; i <= n * m; i ++ )
	{
		if (ind[i] == 0)
		{
			flag = true;
			st[i] = true;
			dfs(i);
			break;
		}
	}
	if (flag) // 已经dfs过一次
	{
		for (int i = 1; i <= n * m; i ++ ) // 检查是否还有点没遍历到
		{
			if (!st[i])
			{
				cout << "No\n";
				return;
			}
		}
		cout << "Yes\n";
	}
	else // 点都在环上
	{
		st[1] = true;
		dfs(1);
		for (int i = 1; i <= n * m; i ++ ) // 检查是否还有点没遍历到
		{
			if (!st[i])
			{
				cout << "No\n";
				return;
			}
		}
		cout << "Yes\n";
	}
}

signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);

	int t = 1;
	cin >> t;
	while (t--)
	{
		solve();
	}
}

C - 0689（思维 + 后缀统计）

  • 从前往后枚举每个地方为起点，终点只需要看它之后有多少个数作为终点，rotate 一下和起点不一样：
    • 以 0 0 0 为起点，终点可以是 6 6 6 , 8 8 8 , 9 9 9
    • 以 6 6 6 为起点，终点可以是 0 0 0 , 6 6 6 , 8 8 8
    • 以 8 8 8 为起点，终点可以是 0 0 0 , 6 6 6 , 9 9 9
    • 以 9 9 9 为起点，终点可以是 0 0 0 , 8 8 8 , 9 9 9
  • 为什么可以这么计算呢，因为如果开头结尾 rotate 一下是一样的，那就可以直接选择更短的区间进行 rotate 达到一样的效果
  • 所以统计一下后缀，也就是每个数后面有多少个 0689，计算一下就行了
  • 坑点是需不需要加自身呢？如果有 0 或者 8 的话，rotate 一下就是本身，所以需要加自身，另一种需要加自身的情况是同时出现了 6 和 9，因为这两个数相互 rotate 相等
#include <bits/stdc++.h>

using namespace std;

#define int long long
#define double long double
using i64 = long long;

typedef pair<int, int> PII;
typedef pair<int, char> PIC;
typedef pair<double, double> PDD;
typedef pair<int, PII> PIII;
typedef pair<int, pair<int, bool>> PIIB;

const int N = 1e6 + 10;
const int maxn = 1e6;
const int mod = 1e9 + 7;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;

void solve()
{
	string s; cin >> s;
	int n = s.size();
	s = " " + s;
	vector<vector<int>> cnt(n + 2, vector<int>(4));
	int ans = 0;
	bool flag = false, f1 = false, f2 = false;
	for (int i = n; i >= 1; i -- )
	{
		for (int j = 0; j < 4; j ++ )
		{
			cnt[i][j] = cnt[i + 1][j];
		}
		if (s[i] == '0')
		{
			flag = true;
			cnt[i][0] ++ ;
			ans += cnt[i][1] + cnt[i][2] + cnt[i][3];
		}
		else if (s[i] == '6')
		{
			f1 = true;
			cnt[i][1] ++ ;
			ans += cnt[i][0] + cnt[i][1] + cnt[i][2];
		}
		else if (s[i] == '8')
		{
			flag = true;
			cnt[i][2] ++ ;
			ans += cnt[i][0] + cnt[i][1] + cnt[i][3];
		}
		else if (s[i] == '9')
		{
			f2 = true;
			cnt[i][3] ++ ;
			ans += cnt[i][0] + cnt[i][2] + cnt[i][3];
		}
	}
	if (f1 && f2) flag = true;
	if (flag) cout << ans + 1 << '\n';
	else cout << ans << '\n';
}

signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);

	int t = 1;
	cin >> t;
	while (t--)
	{
		solve();
	}
}

D - Pick Up（思维）

  • 答案初始化为baobao直接去商场的时间
  • x a ,   y a ,   x b ,   y b x_a,\ y_a, \ x_b,\ y_b xa​, ya​, xb​, yb​ 形成的矩形中，找出距离商场最近的点 d d d，两个人先走到 d d d 再去商场和直接去商场的路径是一样的
  • 如果baobao先到 d d d，那DreamGrid可以在去商场的路上带上baobao，所以答案和DreamGrid去商场的时间取最小值
  • 如果DreamGrid先到 d d d，那他会先去接baobao，从出发到接到baobao的时间可以计算出来，另外加上一起去商场的时间就可以了
  • 坑点是卡cin
#include <bits/stdc++.h>

using namespace std;

#define int long long
#define double long double
using i64 = long long;

typedef pair<int, int> PII;
typedef pair<int, char> PIC;
typedef pair<double, double> PDD;
typedef pair<int, PII> PIII;
typedef pair<int, pair<int, bool>> PIIB;

const int N = 1e5 + 10;
const int maxn = 1e6;
const int mod = 1e9 + 7;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;

double cal(int x1, int y1, int x2, int y2, double v)
{
	return 1.0 * (labs(x1 - x2) + labs(y1 - y2)) / v;
}

void solve()
{
	double a, b;
	int xa, ya, xb, yb, xc, yc;
	scanf("%Lf%Lf%lld%lld%lld%lld%lld%lld", &a, &b, &xa, &ya, &xb, &yb, &xc, &yc);
	double ans = cal(xa, ya, xc, yc, a); // baobao到商场
	int l = min(xa, xb), r = max(xa, xb);
	int u = min(ya, yb), d = max(ya, yb);
	int xd = max(l, min(r, xc)), yd = max(u, min(d, yc));
	double ta = cal(xa, ya, xd, yd, a), tb = cal(xb, yb, xd, yd, b);
	if (ta < tb) ans = min(ans, cal(xb, yb, xc, yc, b));
	else
	{
		double t = cal(xa, ya, xb, yb, a + b);
		double dis = labs(xa - xc) + labs(ya - yc) - t * a;
		ans = min(ans, t + dis / b);
	}
	printf("%.8Lf\n", ans);
}

signed main()
{
	// ios::sync_with_stdio(false);
	// cin.tie(0), cout.tie(0);

	int t = 1;
	cin >> t;
	while (t--)
	{
		solve();
	}
}

E - Turn It Off（二分）

  • 直接二分，不要再无脑贪心了
#include <bits/stdc++.h>

using namespace std;

#define int long long
#define double long double
using i64 = long long;

typedef pair<int, int> PII;
typedef pair<int, char> PIC;
typedef pair<double, double> PDD;
typedef pair<int, PII> PIII;
typedef pair<int, pair<int, bool>> PIIB;

const int N = 1e6 + 10;
const int maxn = 1e6;
const int mod = 1e9 + 7;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;

void solve()
{
	int n, k;
	cin >> n >> k;
	string s; cin >> s;
	int l = 1, r = n;
	auto check = [&](int mid)
	{
		int cnt = 0;
		for (int i = 0; i < s.size(); i ++ )
		{
			if (s[i] == '0') continue;
			cnt ++ ;
			i += mid - 1;
		}
		if (cnt > k) return false;
		else return true;
	};
	while (l < r)
	{
		int mid = l + r >> 1;
		if (check(mid)) r = mid;
		else l = mid + 1;
	}
	cout << r << '\n';
}

signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);

	int t = 1;
	cin >> t;
	while (t--)
	{
		solve();
	}
}

F - K-hour Clock（思维）

  • 当 x + y < z x+y<z x+y<z ，不可能实现
  • 当 x + y = z x+y=z x+y=z ，输出比 z z z 大的任何一个数
  • 当 x + y > z x+y>z x+y>z，肯定是先从 x x x 到 k k k，再从 0 0 0 到 z z z，所以我们先把后面多的 z z z 减掉，再把前面少的 x x x 加上，这样得到的数一定是 k k k 的倍数，判断一下这个数是不是都大于 x x x 和 y y y，是的话直接输出就好了
#include <bits/stdc++.h>

using namespace std;

#define int long long
#define double long double
using i64 = long long;

typedef pair<int, int> PII;
typedef pair<int, char> PIC;
typedef pair<double, double> PDD;
typedef pair<int, PII> PIII;
typedef pair<int, pair<int, bool>> PIIB;

const int N = 1e6 + 10;
const int maxn = 1e6;
const int mod = 1e9 + 7;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;

void solve()
{
	int x, y, z; cin >> x >> y >> z;
	if (x + y < z)
	{
		cout << -1 << '\n';
		return;
	}
	if (x + y == z)
	{
		cout << z + 1 << '\n';
		return;
	}
	int tmp = y - z + x;
	int maxx = max(x, z);
	if (tmp > maxx) cout << tmp << '\n';
	else cout << -1 << '\n';
}

signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);

	int t = 1;
	cin >> t;
	while (t--)
	{
		solve();
	}
}

H - To the Park（构造）

  • 首先 1 1 1 一定不行，然后从大到小枚举质数，如果质数的两倍大于 n n n 肯定不行
  • 把质数的倍数存起来，如果在 n n n 以内的有偶数个，正好两两配对，如果奇数个，就单独把两倍的质数提出来，之后和其余没用上的偶数配对
#include <bits/stdc++.h>

using namespace std;

#define int long long
#define double long double
using i64 = long long;

typedef pair<int, int> PII;
typedef pair<int, char> PIC;
typedef pair<double, double> PDD;
typedef pair<int, PII> PIII;
typedef pair<int, pair<int, bool>> PIIB;

const int N = 1e5 + 10;
const int maxn = 1e6;
const int MAXN = 1e5 + 10;
const int mod = 1e9 + 7;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;

bool isprime[MAXN]; // isprime[i]表示i是不是素数
vector<int> prime;
int n; // 上限，即筛出<=n的素数
int cnt; // 已经筛出的素数个数

void euler()
{
    memset(isprime, true, sizeof(isprime)); // 先全部标记为素数
    isprime[1] = false; // 1不是素数
	prime.push_back(0);
    for(int i = 2; i <= 1e5; ++i) // i从2循环到n（外层循环）
    {
        if(isprime[i])
		{
			prime.push_back(i);
			cnt ++ ;
		}
        // 如果i没有被前面的数筛掉，则i是素数
        for(int j = 1; j <= cnt && i * prime[j] <= 1e5; ++j)
        // 筛掉i的素数倍，即i的prime[j]倍
        // j循环枚举现在已经筛出的素数（内层循环）
        {
            isprime[i * prime[j]] = false;
            // 倍数标记为合数，也就是i用prime[j]把i * prime[j]筛掉了
            if(i % prime[j] == 0) break;
            // 最神奇的一句话，如果i整除prime[j]，退出循环
            // 这样可以保证线性的时间复杂度
        }
    }
}

void solve()
{
	int n; cin >> n;
	vector<bool> st(n + 1); // 哪些数已经被用过了
	vector<int> noused;
	vector<PII> ans;
	for (int i = cnt; i > 1; i -- )
	{
		int num = prime[i];
		if (num * 2 > n) continue;
		vector<int> tmp;
		int idx = 2;
		tmp.push_back(num);
		while (num * idx <= n)
		{
			if (!st[num * idx])
			{
				st[num * idx] = true;
				tmp.push_back(num * idx);
			}
			idx ++ ;
		}
		if (tmp.size() & 1)
		{
			noused.push_back(2 * num);
			ans.push_back({tmp[0], tmp[2]});
			for (int i = 3; i < tmp.size(); i += 2 ) ans.push_back({tmp[i], tmp[i + 1]});
		}
		else
		{
			for (int i = 0; i < tmp.size(); i += 2) ans.push_back({tmp[i], tmp[i + 1]});
		}
	}
	for (int i = 2; i <= n; i += 2) if (!st[i]) noused.push_back(i); 
	for (int i = 0; i < (int)(noused.size()) - 1; i += 2) ans.push_back({noused[i], noused[i + 1]});
	cout << ans.size() << ' ';
	for (auto t : ans) cout << t.first << ' ' << t.second << ' ';
	cout << '\n';
}

signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);

	euler();
	int t = 1;
	cin >> t;
	while (t--)
	{
		solve();
	}
}

I - Unrooted Trie（dfs序 + 差分）

  • 有两种情况，这棵树就一定不是合法的字典树：

    • 一个结点连接了大于 2 个相同的字母
    • 一个结点连接了大于 1 种出现两次的字母

  • 如果不处于以上两种情况，我们只需要看那些地方不能当做根，做个标记，没做标记的地方统计答案

  • 如果一个结点连接的所有字母都只出现了一次，那对答案没有影响，如果有一个字母出现了两次，根结点必然在这两个点所在的子树里，对整个子树打标记，想到可以用 dfs 序

  • 先随便选个点开始 dfs 一下求出 dfs 序，然后遍历所有点，遍历到的点记为 u u u，相邻的字母相同的点记作 v 1 v_1 v1​ 和 v 2 v_2 v2​

    • 如果 d f n [ u ] < d f n [ v 1 ] dfn[u]<dfn[v_1] dfn[u]<dfn[v1​] 且 d f n [ u ] < d f n [ v 2 ] dfn[u]<dfn[v_2] dfn[u]<dfn[v2​]，说明 u u u 是 v 1 v_1 v1​ 和 v 2 v_2 v2​ 的父结点，那除了两个子树的其余部分都不能作为根结点，就先把全体打上+1标记，两个子树打上-1标记
    • 否则， d f n [ u ] dfn[u] dfn[u] 一定处于 d f n [ v 1 ] dfn[v_1] dfn[v1​] 和 d f n [ v 2 ] dfn[v_2] dfn[v2​] 之间，不能作为根结点的部分就是 u u u 的子树除去 v 1 v_1 v1​ 或者 v 2 v_2 v2​ 的子树部分

  • 差分打标记就行

#include <bits/stdc++.h>

using namespace std;

#define int long long
#define double long double
using i64 = long long;

typedef pair<int, int> PII;
typedef pair<int, char> PIC;
typedef pair<double, double> PDD;
typedef pair<int, PII> PIII;
typedef pair<int, pair<int, bool>> PIIB;

const int N = 1e5 + 10;
const int maxn = 1e6;
const int mod = 1e9 + 7;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;

void solve()
{
	int n; cin >> n;
	vector<vector<PII>> g(n + 1);
	for (int i = 0; i < n - 1; i ++ )
	{
		int u, v;
		char c;
		cin >> u >> v >> c;
		g[u].push_back({v, c - 'a'});
		g[v].push_back({u, c - 'a'});
	}
	int timestamp = 0;
	vector<int> dfn1(n + 1), dfn2(n + 1);
	function<void(int, int)> dfs = [&](int u, int fa)
	{
		dfn1[u] = ++ timestamp;
		for (int i = 0; i < g[u].size(); i ++ )
		{
			int j = g[u][i].first, c = g[u][i].second;
			if (j == fa) continue;
			dfs(j, u);
		}
		dfn2[u] = timestamp;
	};
	dfs(1, -1);
	vector<int> diff(n + 2);
	for (int i = 1; i <= n; i ++ )
	{
		vector<vector<int>> cnt(26);
		int flag = -1;
		for (int j = 0; j < g[i].size(); j ++ )
		{
			int v = g[i][j].first, c = g[i][j].second;
			cnt[c].push_back(v);
			if (cnt[c].size() > 2)
			{
				cout << 0 << '\n';
				return;
			}
			else if (cnt[c].size() == 2)
			{
				if (flag != -1)
				{
					cout << 0 << '\n';
					return;
				}
				else flag = c;
			}
		}

		if (flag == -1) continue;

		int v1 = cnt[flag][0], v2 = cnt[flag][1];
		if (dfn1[v1] > dfn1[v2]) swap(v1, v2);
		if (dfn1[i] < dfn1[v1] && dfn1[i] < dfn1[v2])
		{
			diff[1] ++ , diff[n + 1] ++ ;
			diff[dfn1[v1]] -- , diff[dfn2[v1] + 1] ++ ;
			diff[dfn1[v2]] -- , diff[dfn2[v2] + 1] ++ ;
		}
		else
		{
			diff[dfn1[i]] ++ , diff[dfn2[i] + 1] -- ;
			diff[dfn1[v2]] -- , diff[dfn2[v2] + 1] ++ ;
		}
	}

	int ans = 0;
	for (int i = 1; i <= n; i ++ )
	{
		diff[i] += diff[i - 1];
		if (diff[i] == 0) ans ++ ;
	}
	cout << ans << '\n';
}

signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);

	int t = 1;
	cin >> t;
	while (t--)
	{
		solve();
	}
}

J - Coolbits（位运算）

  • 按位考虑答案应该是很常见的思路了
  • 从高位往低位考虑，假设当前在考虑第 i i i 位，用 r e s [ j ] res[j] res[j] 表示第 j j j 个区间从最高位到第 i + 1 i+1 i+1 位选的数：
    • 第 i i i 位为 1 1 1，条件是对于所有的 j j j， [ r e s j + 2 i ,   r e s j + 2 i + 1 − 1 ] [res_j+2^i,\ res_j+2^{i+1}-1] [resj​+2i, resj​+2i+1−1] 必须与 [ l j ,   r j ] [l_j,\ r_j] [lj​, rj​] 有交集，对于第 j j j 个数，让 r e s [ j ] res[j] res[j] 加上 2 i 2^i 2i 即可
    • 否则第 i i i 位为 0 0 0：
      • 如果 [ r e s j + 2 i ,   r e s j + 2 i + 1 − 1 ] [res_j+2^i,\ res_j+2^{i+1}-1] [resj​+2i, resj​+2i+1−1] 和 [ l j ,   r j ] [l_j,\ r_j] [lj​, rj​] 没有交集，第 j j j 个数的第 i i i 位取 0 0 0， r e s [ j ] res[j] res[j] 不做改变
      • 如果有交集，就看一下 r e s j + 2 i − 1 res_j+2^i-1 resj​+2i−1 在不在 [ l j ,   r j ] [l_j,\ r_j] [lj​, rj​]，如果在的话，直接第 i i i 位填 0 0 0，后面全填 1 1 1 就可以了（第 j j j 个数之后都不需要再考虑了），如果不在这一位就只能填 1 1 1
#include <bits/stdc++.h>

using namespace std;

#define int long long
#define double long double
using i64 = long long;

typedef pair<int, int> PII;
typedef pair<int, char> PIC;
typedef pair<double, double> PDD;
typedef pair<int, PII> PIII;
typedef pair<int, pair<int, bool>> PIIB;

const int N = 1e5 + 10;
const int maxn = 1e6;
const int mod = 1e9 + 7;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;

void solve()
{
	int n; cin >> n;
	vector<PII> a(n + 1);
	vector<int> res(n + 1);
	vector<bool> st(n + 1);
	for (int i = 1; i <= n; i ++ ) cin >> a[i].first >> a[i].second;
	int ans = 0;
	for (int i = 31; i >= 0; i -- ) // 目前考虑到哪一位了
	{
		bool flag = true; // 当前位能不能填1
		for (int j = 1; j <= n; j ++ )
		{
			if (st[j]) continue;
			int tmpl = res[j] + (1ll << i), tmpr = res[j] + (1ll << (i + 1)) - 1;
			int l = a[j].first, r = a[j].second;
			if (r < tmpl || l > tmpr)
			{
				flag = false;
				break;
			}
		}
		if (flag) // 当前位取1
		{
			for (int j = 1; j <= n; j ++ )
			{
				if (st[j]) continue;
				res[j] += (1 << i);
			}
			ans += (1ll << i);
		}
		else // 当前位取0
		{
			for (int j = 1; j <= n; j ++ )
			{
				if (st[j]) continue;
				int tmpl = res[j] + (1ll << i), tmpr = res[j] + (1ll << (i + 1)) - 1;
				int l = a[j].first, r = a[j].second;
				if (r >= tmpl && l <= tmpr)
				{
					int tmp = res[j] + (1ll << i) - 1;
					if (tmp >= l && tmp <= r)
					{
						res[j] += (1ll << i) - 1;
						st[j] = true;
					}
					else res[j] += (1ll << i);
				}
			}
		}
	}
	cout << ans << '\n';
}

signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);

	int t = 1;
	cin >> t;
	while (t--)
	{
		solve();
	}
}

K - Escape Plan（Dijkstra变种）

  • 从终点开始跑最短路，但是只有堆顶出现 d [ u ] d[u] d[u] 次 u u u 之后才能更新 d i s t [ u ] dist[u] dist[u]
#include <bits/stdc++.h>

using namespace std;

#define int long long
#define double long double
using i64 = long long;

typedef pair<int, int> PII;
typedef pair<int, char> PIC;
typedef pair<double, double> PDD;
typedef pair<int, PII> PIII;
typedef pair<int, pair<int, bool>> PIIB;

const int N = 1e5 + 10;
const int maxn = 1e6;
const int MAXN = 1e5 + 10;
const int mod = 1e9 + 7;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;

void solve()
{
	int n, m, k;
	cin >> n >> m >> k;
	vector<int> dist(n + 1, INF), e(k + 1);
	priority_queue<PII, vector<PII>, greater<PII>> pq;
	for (int i = 1; i <= k; i ++ )
	{
		int x; cin >> x;
		e[i] = x;
		pq.push({0, x});
	}
	vector<int> d(n + 1);
	for (int i = 1; i <= n; i ++ ) cin >> d[i];
	for (int i = 1; i <= k; i ++ ) d[e[i]] = 0;
	vector<vector<PII>> g(n + 1);
	for (int i = 1; i <= m; i ++ )
	{
		int u, v, w;
		cin >> u >> v >> w;
		g[u].push_back({v, w});
		g[v].push_back({u, w});
	}
	while (pq.size())
	{
		auto t = pq.top();
		pq.pop();

		int dd = t.first, ver = t.second;
		if (d[ver] <= 0)
		{
			if (dist[ver] > dd) dist[ver] = dd;
			else continue;
		}
		else
		{
			d[ver] -- ;
			continue;
		}

		for (int i = 0; i < g[ver].size(); i ++ )
		{
			int j = g[ver][i].first, w = g[ver][i].second;
			if (dist[j] > dd + w)
			{
				pq.push({dd + w, j});
			}
		}
	}
	if (dist[1] == INF) cout << -1 << '\n';
	else cout << dist[1] << '\n';
}

signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);

	int t = 1;
	cin >> t;
	while (t--)
	{
		solve();
	}
}

L - Digit Product（签到）

  • 每十个数必会出现一个 0，所以直接遍历就行，碰到 0 直接退出
#include <bits/stdc++.h>

using namespace std;

#define int long long
#define double long double
using i64 = long long;

typedef pair<int, int> PII;
typedef pair<int, char> PIC;
typedef pair<double, double> PDD;
typedef pair<int, PII> PIII;
typedef pair<int, pair<int, bool>> PIIB;

const int N = 1e6 + 10;
const int maxn = 1e6;
const int mod = 1e9 + 7;
const int mod1 = 954169327;
const int mod2 = 906097321;
const int INF = 0x3f3f3f3f3f3f3f3f;

void solve()
{
	int l, r;
	cin >> l >> r;
	int ans = 1;
	for (int i = l; i <= r; i ++ )
	{
		string s = to_string(i);
		for (auto t : s)
		{
			int num = t - '0';
			if (num == 0)
			{
				cout << 0 << '\n';
				return;
			}
			ans = (ans * num) % mod;
		}
	}
	cout << ans << '\n';
}

signed main()
{
	ios::sync_with_stdio(false);
	cin.tie(0), cout.tie(0);

	int t = 1;
	cin >> t;
	while (t--)
	{
		solve();
	}
}
Texcavator
关注
专栏目录
2019中国大学生程序设计竞赛(CCPC)-网络选拔赛-第七题Shuffle Card
梁同学与Android
08-29 1万+
大赛题目: Shuffle Card Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 6695 Accepted Submission(s): 2061 Problem Description A deck of card co...
【赛后总结+部分题解】2019中国大学生程序设计竞赛（CCPC） - 网络选拔赛
qq_42052818的博客
08-23 291
赛后总结： 　　T：今天状态一般，甚至有点疲惫。然后12点比赛开始，和队友开始看题，从最后往前面看，发现数学题公式看不懂。然后发现队友已经双开做1001和1006了，我看着1007有人A，开始做1007。看了一会发现这是一个简单签到题，构造一下就完事了。然后一遍A，结束。在他们看1008的时候，我回去看1002和1003，1002的题意没看清楚，队友说的也有点模糊，然后不知道怎么下手。...
2019陕西省赛（重温经典）
C_eeking的博客
12-18 1131
2019陕西省赛（重温经典） 为省赛练手，但是省赛延期了（悲）
第十届ICPC陕西省程序设计竞赛题解（思路分析）
感谢您的关注！
10-24 3088
本文章所讲述的是在2022.10.22日举行的ICPC程序设计竞赛 陕西省省赛 之中的题目思路讲解 出题团队在得到出题任务的时候得知区域赛金牌选手是不能参赛的，所以题目整体偏简单，希望给参赛 选手更好的参赛体验，但是赛前一周多又看到所有选手都允许报名了，所以加强了部分题目，且把看起 来简单实际很难的Tree放到了Problem A。 实际的结果是造成了好几道题目变成了防AK题，在此表示歉意。
2019陕西省赛(J - Coolbits)
weixin_63128867的博客
03-21 553
思路：因为数据范围是1e9,所以每次check一下（1<<i）也就30位，然后在check的过程中，如果用l[i]进行操作之后有一次比用r[i]操作之后还要大的话，肯定是不行的，就直接break|return 0，也就是为了让结果最大，不能出现(1<<i)这一位，否则就是可以的，枚举完每一区间，然后对所有区间进行修改，最后得出答案。题意：给你n个区间l,r,然后从这每个区间里面选取一个数，让他们的bitwise and的值最大，求出这个值。时间复杂度：其实也就是n*30，不会超时。
2019年山东省第十届ACM程序设计竞赛 比赛总结
LSD20164388的博客
05-13 2059
首先恭喜自己获得了acm生涯中第一块，也是最后一块省赛的奖牌。 -----------------------------------------------------------------------时光倒流---------------------------------------------------------------------------- 周六早上8点校门口集合，坐车...
ACM2019陕西省赛-ZOJ4128-0689（思维）
QAQ
07-17 1499
We call a string as a 0689-string if this string only consists of digits ‘0’, ‘6’, ‘8’ and ‘9’. Given a 0689-string sss of length nnn, one must do the following operation exactly once: select a non-em...
ACM2019陕西省赛-ZOJ4127-Grid with Arrows（有向图 欧拉路径）
QAQ
06-27 1079
题目链接 题目大意 m*n的矩阵，给一个格子都给了一个方向和步数，指向另一个格子。问能否从某个格子开始，按照给的方向和步数，走遍所有的格子。 就是求能否一笔走完所有的格子。 思路 用欧拉路径，判断所有点的出度入度。有两种情况：如果可以是欧拉回路，那么一定是一个环，这时候所有点的出度等于入度；或者是一条长链，终点可以指向任意的方向，此时起点的入度比出度小1，终点的入度比出度大1，其余的相等...
2019年ACM ICPC西安邀请赛赛后总结及部分题解
鸡尾酒QQQ
05-20 2127
A题 温暖的签到题，一眼秒了 L题 第二个就开了L题，因为看上去是个打表，写了个bfs打表，发现规律和%4的余数有关（1，3要特判），31分钟1A 此时队友给我读了D和M题，我去开D，他们写M。然而他们拒绝了我的二分，非要写最短路。然后半小时后发现算法假了，在我苦苦哀求之下写了二分+bfs M题 二分升级次数，假设二分到mid，边权小于mid*d的可以通过，否则不能通过，总共可以通过mid*...
基于STM32F407的电子设计大赛2019C题线路负载测试程序
05-03
本设计报告主要关注在2019年的陕西省大学生模拟及模数混合电路应用设计竞赛中，基于STM32F407微控制器的电子设计方案，该方案涉及了晶体管放大电路、乙类功率放大器以及非线性失真测量。其中，STM32F407作为核心控制...
2022年陕西省职业院校技能大赛中职组网络安全赛项规程
热门推荐
Jay
04-23 1万+
2022年陕西省职业院校技能大赛中职组 网络安全赛项规程 一、赛项名称 赛项名称：网络安全 赛项归属： 信息技术类 二、竞赛目的 为检验中职学校网络信息安全人才培养成效，促进网络信息安全专业教学改革，培养大批既满足国家网络安全战略需要有具备世界水平的优秀技能人才，在社会上营造“技能改变命运、匠心成就人生”的崇尚技能的氛围，国家教育部联合多部委联合特举办本赛项。 （一）检验教学成效 竞赛内容涵盖了网络信息安全行业企业岗位对学生职业技能的最新要求，竞赛过程为完整工作任务的具体实施，竞赛评价标准符
【Web前端大作业】基于HTML+CSS+JavaScript制作西北大学新闻网站（7页）
HTML网页设计
08-09 673
🏫 校园网页设计 、学校班级网页制作、学校官网、小说书籍、等网站的设计与制作。🏷️HTML静态网页设计作业使用dreamweaver制作，采用DIV+CSS布局，共有多个页面，首页使用CSS排版比较丰富，色彩鲜明有活力。顶部导航及底部区域背景色为100%宽度，主体内容区域宽度🏅 一套优质的💯网页设计应该包含 (具体可根据个人要求而定)📔网站布局方面：计划采用目前主流的、能兼容各大主流浏览器、显示效果稳定的浮动网页布局结构。📓网站程序方面：计划采用最新的网页编程语言HTML5+CSS3+JS程序语......
【项目实战】别出心裁的小程序简历，让面试官耳目一新（第一个自己独立完成的小程序）
weixin_43534575的博客
07-28 4720
本篇博客将介绍使用微信小程序制作简历的实现过程。 一：配置开发环境 开发环境搭载： 1.在浏览器搜索 微信开发者工具，进入官网进行下载https://developers.weixin.qq.com/miniprogram/dev/devtools/devtools.html 进行下载 2.注册微信开发者账号，进入微信公众平台https://mp.weixin.qq.com/ 3.登录微信公众平台进行开发设置，注意APPid的保存 4.登录微信开发者工具进行初次体验 二：小程序公共信息配置 1.删除inde
岛屿个数（dfs)
初九·潜龙勿用的博客
04-07 5161
小蓝得到了一副大小为M×N的格子地图，可以将其视作一个只包含字符0（代表海水）和1（代表陆地）的二维数组，地图之外可以视作全部是海水，每个岛屿由在上/下/左/右四个方向上相邻的1相连接而形成。x0​y0​x1​y1​...xk−1​yk−1​，其中 (x,y) 是由xi​yi​通过上/下/左/右移动一次得来的 (0≤i≤k−1)，此时这 k 个格子就构成了一个 “环”。
二叉树系列 10/11
2301_78191305的博客
10-11 426
在这些路径中，只有红色和绿色的路径是伪回文路径，因为红色路径 [2,3,3] 存在回文排列 [3,2,3] ，绿色路径 [2,1,1] 存在回文排列 [1,2,1]。总共有 3 条从根到叶子的路径：红色路径 [2,3,3] ，绿色路径 [2,1,1] 和路径 [2,3,1]。（如果 A 的任何子节点之一为 B，或者 A 的任何子节点是 B 的祖先，那么我们认为 A 是 B 的祖先）（一个节点的祖父节点是指该节点的父节点的父节点。」的，当它满足：路径经过的所有节点值的排列中，存在一个回文序列。
在顺序结构和链式结构的线性表上实现顺序检索算法
m0_56332819的博客
10-13 247
在顺序结构和链式结构的线性表上实现顺序检索算法，C语言
【从零开始的LeetCode-算法】3099. 哈沙德数
最新发布
qq_40878316的博客
10-15 191
如果一个整数能够被其各个数位上的数字之和整除，则称之为。各个数位上的数字之和，否则，返回。各个数位上的数字之和为。各个数位上的数字之和为。不是哈沙德数，答案是。
力扣10.13
qq_40052678的博客
10-13 384
如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。每次操作，你可以取一枚 没有碎 的鸡蛋并把它从任一楼层。，以此类推，因此只需要判断最后的层数是否超过建筑高即可。楼层或比它低 的楼层落下的鸡蛋都 不会碎。函数传入操作次数k，可以发现，最优情况一定先在。确切的值 的 最小操作次数 是多少？的楼层落下的鸡蛋都 会碎 ，从。枚相同 的鸡蛋，和一栋从第。请你计算并返回要确定。
c语言练习题2(字符串和函数的使用)
m0_74859128的博客
10-10 373
回文函数用于判断一个给定的字符串是否为回文。输入是一个字符数组（字符串），输出是一个布尔值，表示该字符串是否为回文。编写一个 C 语言程序，计算两个整数在二进制表示中有多少位不同。2. 比较这两个整数在二进制表示中的每一位（共32位）是否不同。1. 提示用户输入两个整数。3. 统计不同的位的数量。4. 输出不同的位数。
2009年全国大学生电子设计竞赛TI优秀作品：光伏并网发电模拟装置
这篇论文合集收录了2009年全国大学生电子设计大赛的优秀作品，其中包括来自四川、陕西、湖北和江苏赛区的部分参赛团队的成果。特别地，这些作品得到了德州仪器半导体技术（上海）有限公司大学计划部的认可和精选。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Texcavator

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值