【CodeForces Round #550】A-F | 模拟 | 贪心 | 高精 | BFS | 二分图 | E

于 2019-04-01 00:24:17 发布
阅读量182 收藏
点赞数
分类专栏： A | ACM比赛 C | CodeForces E | 二分图 G | 高精 S | 搜索 T | 贪心 S | 思维 文章标签： codeforces 贪心 思维 BFS 二分图
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42102584/article/details/88938757
版权

今年怎么没有愚人节比赛了   CF你看看人家洛谷  
唉鸭原来那边还没到愚人节呢… 愚人节比赛还是有的，在今晚 qwq


【CodeForces 1144   A-F】


Tags：模拟 贪心 BFS 高精 二分图判断




A. Diverse Strings


[A] 题意

给定 T ≤ 100 T \le 100 T≤100 个小写字母组成的字符串（ l e n i ≤ 100 len_i \le 100 leni​≤100）

问这个字符串所包含的字母是否满足以下条件：

  • 1.每种字母至多出现一次
  • 2.出现的字母是相邻的

比如 a b 、 b a 、 a b c 、 a c b 、 b a c 、 b c a 、 c a b 、 c b a ab、ba、abc、acb、bac、bca、cab、cba ab、ba、abc、acb、bac、bca、cab、cba 都是满足条件的
a a 、 a b b 、 a c 、 a z aa、abb、ac、az aa、abb、ac、az 都不是满足条件的


[A] 思路

just implementation.

模拟，简单计数即可。

时间复杂度： O ( Σ   l e n i ) O(\Sigma\ len_i) O(Σ leni​)



[A] 代码

#include<cstdio>

#define GC getchar()
#define _SN(x) {char _c=GC,_v=1;for(x=0;_c<48||_c>57;_c=GC)if(_c==45)_v=-1;for(;_c>=48&&_c<=57;x=(x<<1)+(x<<3)+_c-48,_c=GC);if(_v==-1)x=-x;}
#define _SAN(a,n) {auto _i=0,_n=n;for(;_i<_n;++_i)_SN(a[_i])}
#define _SA(a,l,r) {auto _i=l,_r=r;for(;_i<_r;++_i)_SN(a[_i])}
#define _gS(_1, _2, _3, _sc, ...) _sc
#define sc(...) _gS(__VA_ARGS__,_SA,_SAN,_SN, ...)(__VA_ARGS__)
#define _G1(_1) int _1;sc(_1)
#define _G2(_1,_2) int _1,_2;sc(_1)sc(_2)
#define _G3(_1,_2,_3) int _1,_2,_3;sc(_1)sc(_2)sc(_3)
#define _gG(_1,_2,_3,_get, ...) _get
#define get(...) _gG(__VA_ARGS__,_G3,_G2,_G1, ...)(__VA_ARGS__)


char s[666];


int main()
{
	get(T)
	while (T--)
	{
		scanf("%s", s);
		int hs[266] = {0};

		for (char *p=s; *p; ++p)
			++hs[*p];

		int cnt = 0;
		for (int i=1; i<266; ++i)
		{
			if (hs[i]&&!hs[i-1])
				++cnt;
			if (hs[i]>=2)
				cnt = 666;
		}

		puts(cnt == 1 ? "Yes" : "No");
	}

	return 0;
}




B. Parity Alternated Deletions


[B] 题意

给定 n ≤ 2000 n \le 2000 n≤2000 个正整数（ a i ≤ 1 0 6 a_i \le 10^6 ai​≤106）

现按如下规则进行删除操作：

  • 1.第一次删除时，可任选一个数删掉
  • 2.其他时候，如果刚才删了奇数，则这次就只能删偶数；如果刚才删了偶数，则这次就只能删奇数
  • 3.当无法再删数时就停止，然后统计没删的数之和为 s u m sum sum（都删完了的话， s u m = 0 sum = 0 sum=0）

问按照这样的规则， s u m sum sum 能取得的最小值是多少。


[B] 思路

就直接贪心啦。

把奇数放在 b b b 数组中，偶数放在 c c c 数组中，各自排升序，然后同时删除倒数 m i n { l e n b ， l e n c } min\{len_b，len_c\} min{lenb​，lenc​} 这么多个数。

然后如果还有数组有剩的话，再把它的最后一个给删掉。

然后求和就是答案（数据刚好不会爆 i n t int int，这不符合愚人节 出题人好良心啊 qwq）。

时间复杂度： O ( n l o g n ) O(nlogn) O(nlogn)



[B] 代码

（好懒啊…就vector算了）

#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>

#define GC getchar()
#define _SN(x) {char _c=GC,_v=1;for(x=0;_c<48||_c>57;_c=GC)if(_c==45)_v=-1;for(;_c>=48&&_c<=57;x=(x<<1)+(x<<3)+_c-48,_c=GC);if(_v==-1)x=-x;}
#define _SAN(a,n) {auto _i=0,_n=n;for(;_i<_n;++_i)_SN(a[_i])}
#define _SA(a,l,r) {auto _i=l,_r=r;for(;_i<_r;++_i)_SN(a[_i])}
#define _gS(_1, _2, _3, _sc, ...) _sc
#define sc(...) _gS(__VA_ARGS__,_SA,_SAN,_SN, ...)(__VA_ARGS__)
#define _G1(_1) int _1;sc(_1)
#define _G2(_1,_2) int _1,_2;sc(_1)sc(_2)
#define _G3(_1,_2,_3) int _1,_2,_3;sc(_1)sc(_2)sc(_3)
#define _gG(_1,_2,_3,_get, ...) _get
#define get(...) _gG(__VA_ARGS__,_G3,_G2,_G1, ...)(__VA_ARGS__)
#define _F0N(i,n) for(auto i=0;i<n;++i)
#define _FLR(i,l,r) for(auto i=l,_r=r;i<_r;++i)
#define _gF(_1, _2, _3, _F, ...) _F
#define F(...) _gF(__VA_ARGS__,_FLR,_F0N, ...)(__VA_ARGS__)
#define ALL(X) (X).begin(),(X).end()
#define SORT(X) std::sort(ALL(X))
template<class T>
void PRT(const T _){if(_<0){putchar(45),PRT(-_);return;}if(_>=10)PRT(_/10);putchar(_%10+48);}


std::vector<int> odds, evens;

int main()
{
	get(n)
	F(i, n)
	{
		get(tp)
		if (tp&1)
			odds.emplace_back(tp);
		else
			evens.emplace_back(tp);
	}

	SORT(odds), SORT(evens);
	while (!odds.empty() && !evens.empty())
		odds.pop_back(), evens.pop_back();

	long long sum = 0;
	if (!odds.empty())
		odds.pop_back();

	if (!evens.empty())
		evens.pop_back();

	for (auto e : odds)
		sum += e;
	for (auto e : evens)
		sum += e;

	PRT(sum);

	return 0;
}




C. Two Shuffled Sequences


[C] 题意

给定 1 ≤ n ≤ 2 × 1 0 5 1\le n \le 2\times 10^5 1≤n≤2×105 个数（ 0 ≤ a i ≤ 2 × 1 0 5 0 \le a_i \le 2\times 10^5 0≤ai​≤2×105），

问这个数组是不是通过一个严格递增数组和另一个严格递减数组合成而得到的（合成时可以随意调换元素顺序）。

如果是，输出一种合成可能（输出这两个数组，一个严格递增，另一个严格递减）。

tips：长度为 0 0 0 或 1 1 1 的任意数组都既是严格递增数组又是严格递减数组。


[C] 思路

显然，一个数组是可以满足要求的 当且仅当 其包含数的出现次数皆 ≤ 2 \le2 ≤2

用 m a p map map 计数即可。如果ok的话，顺着取一遍数，再倒着取一遍数即可。

时间复杂度： O ( n l o g n ) O(nlogn) O(nlogn)



[C] 代码

（模板稍微有点过分哈…实在是太懒了 qwq 望谅解）

#include<cstdio>
#include<iostream>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<ctime>
#include<string>
#include<algorithm>
#include<utility>
#include<vector>
#include<list>
#include<map>
#include<set>
#include<unordered_map>
#include<unordered_set>
#include<bitset>
#include<cctype>
#include<climits>

#define GC getchar()
#define _SN(x) {char _c=GC,_v=1;for(x=0;_c<48||_c>57;_c=GC)if(_c==45)_v=-1;for(;_c>=48&&_c<=57;x=(x<<1)+(x<<3)+_c-48,_c=GC);if(_v==-1)x=-x;}
#define _SAN(a,n) {auto _i=0,_n=n;for(;_i<_n;++_i)_SN(a[_i])}
#define _SA(a,l,r) {auto _i=l,_r=r;for(;_i<_r;++_i)_SN(a[_i])}
#define _gS(_1, _2, _3, _sc, ...) _sc
#define sc(...) _gS(__VA_ARGS__,_SA,_SAN,_SN, ...)(__VA_ARGS__)
#define _G1(_1) int _1;sc(_1)
#define _G2(_1,_2) int _1,_2;sc(_1)sc(_2)
#define _G3(_1,_2,_3) int _1,_2,_3;sc(_1)sc(_2)sc(_3)
#define _gG(_1,_2,_3,_get, ...) _get
#define get(...) _gG(__VA_ARGS__,_G3,_G2,_G1, ...)(__VA_ARGS__)
#define _F0N(i,n) for(auto i=0;i<n;++i)
#define _FLR(i,l,r) for(auto i=l,_r=r;i<_r;++i)
#define _gF(_1, _2, _3, _F, ...) _F
#define F(...) _gF(__VA_ARGS__,_FLR,_F0N, ...)(__VA_ARGS__)
#define _FD0(i,n) for(auto i=0;i<=n;++i)
#define _FDL(i,l,r) for(auto i=l,_r=r;i<=_r;++i)
#define _gFD(_1, _2, _3, _FD, ...) _FD
#define FD(...) _gFD(__VA_ARGS__,_FDL,_FD0, ...)(__VA_ARGS__)

#define OPER1(T,x1,b1) inline bool operator<(const T&o)const{return x1 b1 o.x1;}
#define OPER2(T,x1,b1,x2,b2) inline bool operator<(const T&o)const{return x1 b1 o.x1||x1==o.x1&&x2 b2 o.x2;}
#define OPER3(T,x1,b1,x2,b2,x3,b3) inline bool operator<(const T&o)const{return x1 b1 o.x1||x1==o.x1&&(x2 b2 o.x2||x2==o.x2&&x3 b3 o.x3);}

#define LL long long
#define ULL unsigned long long
#define PC putchar
template<class T>
void PRT(const T _){if(_<0){PC(45),PRT(-_);return;}if(_>=10)PRT(_/10);PC(_%10+48);}
template<class T>
void UPRT(const T _){if(_>=10)UPRT(_/10);PC(_%10+48);}

#define CON constexpr
#define T_CASE int CASE;sc(CASE)for(int __=1;__<=CASE;++__)
#define cincout std::cin.tie(nullptr),std::cout.tie(nullptr),std::ios::sync_with_stdio(false);
#define eps 1e-8
#define PI 3.141592653589793
#define MAX_INT 2147483647
#define MIN_INT -2147483648
#define MAX_LL 9223372036854775807
#define MIN_LL -9223372036854775808
#define INF 0x3f3f3f3f
#define LINF 0x3f3f3f3f3f3f3f3fLL
#define endl '\n'
#define priority_queue priority_queue
#define PQ std::priority_queue
#define PR std::pair
#define vector vector
#define VI std::vector<int>
#define MII std::map<int,int>
#define MLI std::map<LL,int>
#define MSI std::map<std::string,int>
#define PII std::pair<int,int>
#define PLI std::pair<LL,int>
#define PSI std::pair<std::string,int>
#define MPFD(k) auto it=mp.find(k)

#define MIN(a, b) ((a)<(b)?(a):(b))
#define MIN3(a, b, c) (MIN(a, MIN(b, c)))
#define MAX(a, b) ((a)>(b)?(a):(b))
#define MAX3(a, b, c) (MAX(a, MAX(b, c)))
#define get_max(a,l,r,_max) auto _max=a[l];for(int _i=l+1,_r=r;_i<_r;++_i)if(_max<a[_i])_max=a[_i]
#define get_min(a,l,r,_min) auto _min=a[l];for(int _i=l+1,_r=r;_i<_r;++_i)if(_min<a[_i])_min=a[_i]
#define ABS(a) ((a)>0?(a):-(a))
#define FABS(a) ((a)>0?(a):-(a))
#define log2n(x) (log(x)/0.69314718055995)
#define MHD(p1, p2) ((p1.x>p2.x?p1.x-p2.x:p2.x-p1.x)+(p1.y>p2.y?p1.y-p2.y:p2.y-p1.y))

#define PB emplace_back
#define EB emplace_back
#define BRK else break
#define ALL(X) (X).begin(),(X).end()
#define SORT(X) std::sort(ALL(X))
#define SORTD(X) std::sort(ALL(X),std::greater<decltype((X)[0])>())
#define swap(a, b) do{auto _t=a; a=b; b=_t;}while(0)
#define mem0(a) memset(a,0,sizeof(a))
#define memf1(a) memset(a,-1,sizeof(a))
#define meminf(a) memset(a,0x3f,sizeof(a))

CON int MN(2e5+7);


MII mp;
int sta[MN], top;

int main()
{
	get(n)
	F(i, n)
	{
		get(tp)
		++mp[tp];
	}

	for (auto &pr : mp)
		if (pr.second >= 3)
			return puts("NO"), 0;

	puts("YES");
	for (auto &pr : mp)
	{
		PRT(pr.first), PC(10);
		--pr.second;
	}

	for (auto &pr : mp)
	{
		if (pr.second)
			sta[top++] = pr.first;
	}
	PRT(top), PC(10);
	for (int i=top-1; i>=0; --i)
		PRT(sta[i]), PC(32);

	return 0;
}




D. Equalize Them All


[D] 题意

给定 1 ≤ n ≤ 2 × 1 0 5 1\le n \le 2\times 10^5 1≤n≤2×105 个数（ 0 ≤ a i ≤ 2 × 1 0 5 0 \le a_i \le 2\times 10^5 0≤ai​≤2×105），

现在提供两种操作：

  • 1.任意选择相邻的两个数，让其中一个数加上这俩数差的绝对值
  • 2.任意选择相邻的两个数，让其中一个数减去这俩数差的绝对值

问最少进行多少次操作就可以让整个数组的数都互相相等，并且输出每一步操作（选择哪种操作、操作哪两个数）


[D] 思路

其实这两种操作就是把某个数赋值给它旁边的那个数

所以可以先贪心选择出最后变成的数是多少（显然是出现次数最多者），再 BFS 得到整个扩散过程

时间复杂度： O ( n ) O(n) O(n)



[D] 代码

#include <cstdio>
#include <unordered_map>

#define GC getchar()
#define _SN(x) {char _c=GC,_v=1;for(x=0;_c<48||_c>57;_c=GC)if(_c==45)_v=-1;for(;_c>=48&&_c<=57;x=(x<<1)+(x<<3)+_c-48,_c=GC);if(_v==-1)x=-x;}
#define _SAN(a,n) {auto _i=0,_n=n;for(;_i<_n;++_i)_SN(a[_i])}
#define _SA(a,l,r) {auto _i=l,_r=r;for(;_i<_r;++_i)_SN(a[_i])}
#define _gS(_1, _2, _3, _sc, ...) _sc
#define sc(...) _gS(__VA_ARGS__,_SA,_SAN,_SN, ...)(__VA_ARGS__)
#define _G1(_1) int _1;sc(_1)
#define _G2(_1,_2) int _1,_2;sc(_1)sc(_2)
#define _G3(_1,_2,_3) int _1,_2,_3;sc(_1)sc(_2)sc(_3)
#define _gG(_1,_2,_3,_get, ...) _get
#define get(...) _gG(__VA_ARGS__,_G3,_G2,_G1, ...)(__VA_ARGS__)
#define _F0N(i,n) for(auto i=0;i<n;++i)
#define _FLR(i,l,r) for(auto i=l,_r=r;i<_r;++i)
#define _gF(_1, _2, _3, _F, ...) _F
#define F(...) _gF(__VA_ARGS__,_FLR,_F0N, ...)(__VA_ARGS__)

#define PC putchar
template<class T>
void PRT(const T _){if(_<0){PC(45),PRT(-_);return;}if(_>=10)PRT(_/10);PC(_%10+48);}
template<class T>
void UPRT(const T _){if(_>=10)UPRT(_/10);PC(_%10+48);}

constexpr int MN(4e5+7);

std::unordered_map<int, int> mp;

int a[MN];
enum DIR
{
	LL, RR, DIRCNT
};
constexpr int dx[DIRCNT]{-1, 1};

struct Node
{
	int idx;
	DIR from;
} q[MN];
bool vis[MN];
int head, tail;


int main()
{
	get(n)
	F(i, n)
	{
		sc(a[i])
		++mp[a[i]];
	}
	
	int max_cnt = 0, kk;
	for (auto &pr : mp)
		if (pr.second > max_cnt)
			max_cnt = pr.second, kk = pr.first;

	PRT(n - max_cnt), PC(10);
	F(i, n)
	{
		if (a[i]==kk)
		{
			if (i-1>=0&&a[i-1]!=kk && !vis[i-1])
				vis[q[tail].idx = i-1] = true, q[tail++].from = RR;
			if (i+1<n&&a[i+1]!=kk && !vis[i+1])
				vis[q[tail].idx = i+1] = true, q[tail++].from = LL;
		}
	}

	while (head!=tail)
	{
		Node now = q[head++];
		printf("%d %d %d\n", (a[now.idx] < kk ? 1 : 2), now.idx+1, now.idx+1 + dx[now.from]);

		F(i, DIRCNT)
		{
			Node next = now;
			next.idx += dx[i];
			if (next.idx>=0 && next.idx<n && a[next.idx]!=kk && !vis[next.idx])
			{
				q[tail++] = next;
				vis[next.idx] = true;
			}
		}
	}

	return 0;
}




E. Median String


[E] 题意

给定两个等长小写字母字符串 s s s， t t t，他们的 l e n ≤ 2 × 1 0 5 len \le 2\times 10^5 len≤2×105

保证 s s s 的字典序在 t t t 前面。

问字典序刚好在 s s s、 t t t 中间的那个序列是啥。


[E] 思路

26进制高精呀。

答案就是 s + t 2 \frac{s+t}{2} 2s+t​。

时间复杂度： O ( l e n ) O(len) O(len)



[E] 代码

#include <cstdio>

#define GC getchar()
#define _SN(x) {char _c=GC,_v=1;for(x=0;_c<48||_c>57;_c=GC)if(_c==45)_v=-1;for(;_c>=48&&_c<=57;x=(x<<1)+(x<<3)+_c-48,_c=GC);if(_v==-1)x=-x;}
#define _SAN(a,n) {auto _i=0,_n=n;for(;_i<_n;++_i)_SN(a[_i])}
#define _SA(a,l,r) {auto _i=l,_r=r;for(;_i<_r;++_i)_SN(a[_i])}
#define _gS(_1, _2, _3, _sc, ...) _sc
#define sc(...) _gS(__VA_ARGS__,_SA,_SAN,_SN, ...)(__VA_ARGS__)
#define _G1(_1) int _1;sc(_1)
#define _G2(_1,_2) int _1,_2;sc(_1)sc(_2)
#define _G3(_1,_2,_3) int _1,_2,_3;sc(_1)sc(_2)sc(_3)
#define _gG(_1,_2,_3,_get, ...) _get
#define get(...) _gG(__VA_ARGS__,_G3,_G2,_G1, ...)(__VA_ARGS__)
#define _F0N(i,n) for(auto i=0;i<n;++i)
#define _FLR(i,l,r) for(auto i=l,_r=r;i<_r;++i)
#define _gF(_1, _2, _3, _F, ...) _F
#define F(...) _gF(__VA_ARGS__,_FLR,_F0N, ...)(__VA_ARGS__)

#define PC putchar
#define CON constexpr

CON int MN(2e5+7);
CON RDX(26);
#define toi(c) c-'a'
#define toc(i) i+'a'

char s[MN], t[MN];
int sum[MN], ans[MN];

int main()
{
	get(len)
	scanf("%s %s", s, t);

	F(i, len)
		sum[i] = toi(s[i]) + toi(t[i]);

	F(i, len)
	{
		ans[i] = (sum[i] >> 1);
		if (sum[i] & 1)
			sum[i+1] += RDX;
	}

	for (int i=len-1; i>=0; --i)
		if (ans[i] >= RDX)
			ans[i-1] += ans[i] / RDX, ans[i] %= RDX;

	F(i, len)
		PC(toc(ans[i]));

	return 0;
}




F. Graph Without Long Directed Paths


[F] 题意

给定 V V V 个点、 E E E 条边的无向连通图（无自环无重边）（ V 、 E V、E V、E 皆 ≤ 2 × 1 0 5 \le 2 \times 10^5 ≤2×105）

问能否把这些无向边变成有向边，使得整个图不存在长度大于 1 1 1 的路径。

如果不能输出 N O NO NO，如果能则输出 Y E S YES YES，然后对每一条边，输出它是否就是按照之前输入顺序变成有向边


[F] 思路

就是判断是不是二分图。二染色 B F S BFS BFS 一下就行啦。

写代码的时候脑子要灵泛一点… 不要把自己给绕进去了

时间复杂度： O ( V + E ) O(V+E) O(V+E)



[F] 代码

#include <cstdio>
#include <unordered_map>

#define GC getchar()
#define _SN(x) {char _c=GC,_v=1;for(x=0;_c<48||_c>57;_c=GC)if(_c==45)_v=-1;for(;_c>=48&&_c<=57;x=(x<<1)+(x<<3)+_c-48,_c=GC);if(_v==-1)x=-x;}
#define _SAN(a,n) {auto _i=0,_n=n;for(;_i<_n;++_i)_SN(a[_i])}
#define _SA(a,l,r) {auto _i=l,_r=r;for(;_i<_r;++_i)_SN(a[_i])}
#define _gS(_1, _2, _3, _sc, ...) _sc
#define sc(...) _gS(__VA_ARGS__,_SA,_SAN,_SN, ...)(__VA_ARGS__)
#define _G1(_1) int _1;sc(_1)
#define _G2(_1,_2) int _1,_2;sc(_1)sc(_2)
#define _G3(_1,_2,_3) int _1,_2,_3;sc(_1)sc(_2)sc(_3)
#define _gG(_1,_2,_3,_get, ...) _get
#define get(...) _gG(__VA_ARGS__,_G3,_G2,_G1, ...)(__VA_ARGS__)
#define _F0N(i,n) for(auto i=0;i<n;++i)
#define _FLR(i,l,r) for(auto i=l,_r=r;i<_r;++i)
#define _gF(_1, _2, _3, _F, ...) _F
#define F(...) _gF(__VA_ARGS__,_FLR,_F0N, ...)(__VA_ARGS__)

#define PC putchar
template<class T>
void PRT(const T _){if(_<0){PC(45),PRT(-_);return;}if(_>=10)PRT(_/10);PC(_%10+48);}
template<class T>
void UPRT(const T _){if(_>=10)UPRT(_/10);PC(_%10+48);}

#define CON constexpr

CON int MN(2e5+7);

int V, E;
struct Edge
{
	int dest, next;
	bool rev;
} edge[2 * MN], re_edge[MN];
int head[MN], tot;
void add_edge(const int u, const int v) {edge[++tot].next = head[u]; edge[tot].dest = v; head[u] = tot;}


std::unordered_map<int, int> mp[MN];
int q[MN];


enum COLOR
{
	BLACK = 2, WHITE = 3
};
int color[MN];


int main()
{
	sc(V)sc(E)
	F(i, E)
	{
		get(u, v)
		add_edge(u, v);
		add_edge(v, u);

		re_edge[i].dest = v,
		re_edge[i].rev = false;

		mp[u][v] = mp[v][u] = i;
	}

	int h = 0, t = 0;
	color[1] = BLACK;

	for (int i=head[1]; i; i=edge[i].next)
	{
		const int v = edge[i].dest;
		color[q[t++]=v] = WHITE;

		int idx = mp[1][v];
		re_edge[idx].rev = re_edge[idx].dest != v;
	}

	while (h!=t)
	{
		int u = q[h++];
		for (int i=head[u]; i; i=edge[i].next)
		{
			const int v = edge[i].dest;
			if (!color[v])
				color[q[t++]=v] = color[u] ^ 1;
			else if (color[v] == color[u])
					return puts("NO"), 0;

			int idx = mp[u][v];
			if (color[u] == BLACK)
				re_edge[idx].rev = re_edge[idx].dest != v;
			else
				re_edge[idx].rev = re_edge[idx].dest == v;
		}
	}

	puts("YES");
	F(i, E)
		UPRT(re_edge[i].rev);

	return 0;
}




Keyu Tian
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值