Codeforces Round #288 (Div. 2)【贪心、单调队列、欧拉通路、STL栈】

最新推荐文章于 2020-08-24 22:03:05 发布
最新推荐文章于 2020-08-24 22:03:05 发布
阅读量126 收藏
点赞数 1
分类专栏： Codeforces 文章标签： Codeforces
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41730082/article/details/103690238
版权

题目链接

A. Pasha and Pixels

  一个贪心判断它是在四周的那一个方块内满足条件即可。直接贪心。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#define _ABS(x, y) ( x > y ? (x - y) : (y - x) )
#define lowbit(x) ( x&( -x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define efs 1e-7
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
#define MP(a, b) make_pair(a, b)
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
int N, M, K;
bool vis[1007][1007] = {false};
inline bool check(int x, int y)
{
    if(vis[x-1][y] && vis[x-1][y-1] && vis[x][y-1]) return true;
    if(vis[x+1][y] && vis[x+1][y-1] && vis[x][y-1]) return true;
    if(vis[x-1][y] && vis[x-1][y+1] && vis[x][y+1]) return true;
    if(vis[x+1][y] && vis[x+1][y+1] && vis[x][y+1]) return true;
    return false;
}
int main()
{
    scanf("%d%d%d", &N, &M, &K);
    int ans = 0;
    for(int i=1, x, y; i<=K; i++)
    {
        scanf("%d%d", &x, &y);
        if(vis[x][y]) continue;
        vis[x][y] = true;
        if(!ans && check(x, y)) ans = i;
    }
    printf("%d\n", ans);
    return 0;
}

 

B. Anton and currency you all know

  贪心，依然是贪心，要么直接找到一个最前面的刚好比它小的偶数，直接交换，不然的话，就是换最后一个偶数了。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#define _ABS(x, y) ( x > y ? (x - y) : (y - x) )
#define lowbit(x) ( x&( -x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define efs 1e-7
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
#define MP(a, b) make_pair(a, b)
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 1e5 + 7;
int N, a[maxN];
char s[maxN];
int main()
{
    scanf("%s", s);
    N = (int)strlen(s);
    bool ou_num = false;
    for(int i=0; i<N; i++)
    {
        a[i] = s[i] - '0';
        if((a[i] & 1) == 0) ou_num = true;
    }
    if(!ou_num) { printf("-1\n"); return 0; }
    int las_val = a[N - 1], las_id = 0;
    bool ok = false;
    for(int i=0; i<N; i++)
    {
        if((a[i] & 1) == 0)
        {
            if(a[i] < las_val)
            {
                swap(a[i], a[N - 1]);
                ok = true;
                break;
            }
            las_id = i;
        }
    }
    if(!ok) swap(a[las_id], a[N - 1]);
    for(int i=0; i<N; i++) printf("%d", a[i]);
    printf("\n");
    return 0;
}

 

C. Anya and Ghosts

  这道题其实我一看觉得就是一个从后往前的单调队列罢了。贪心——标签如是打到。

  直接从后往前，能放多前面就放多前面，然后直接记录答案，此法一定是最贪心的。

  首先，仍然是先要判断是否有可行解，没有直接-1了。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#define _ABS(x, y) ( x > y ? (x - y) : (y - x) )
#define lowbit(x) ( x&( -x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define efs 1e-7
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
#define MP(a, b) make_pair(a, b)
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 305;
int N, T, R, w[maxN], ans = 0;
int que[maxN << 2], top, fail;
int main()
{
    scanf("%d%d%d", &N, &T, &R);
    for(int i=1; i<=N; i++) scanf("%d", &w[i]);
    if(T + 1 < R + 1) { printf("-1\n"); return 0; }
    top = 0; fail = 0;
    for(int i=w[N] - T + R - 1; i>=w[N] - T; i--)
    {
        que[fail++] = i;
        ans ++;
    }
    for(int i = N - 1, need, now_have; i >= 1; i--)
    {
        while(top < fail && que[top] >= w[i])
        {
            top++;
        }
        now_have = fail - top;
        need = R - now_have;
        for(int j=w[i] - T + need - 1; j>=w[i] - T; j--)
        {
            que[fail++] = j;
            ans ++;
        }
    }
    printf("%d\n", ans);
    return 0;
}

 

D. Tanya and Password

  欧拉通路好题！！！

一开始的时候，我想了一下，不知道该怎么解决一个“中断”的问题（可能微机学多了，用了这个名词解释哈哈哈）。

如图类型：

  所以，我们可以拿栈维护一下，重点就是栈，其他XJB操作都是不得正解的！！！

  譬如，我们访问到了，我们访问下一个结点，然后把后继所有访问完了，也就是把后继所有的都是进栈了。于是，是不是满足了我们所要的输出欧拉通路的作用了！！！太巧了，好！

  当然，不要忘记特判，假如大家都是"aaa"的时候，实际上我们要给起点定义的哟～

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#define _ABS(x, y) ( x > y ? (x - y) : (y - x) )
#define lowbit(x) ( x&( -x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define efs 1e-7
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
#define MP(a, b) make_pair(a, b)
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 4e5 + 7;
int N, In_du[maxN] = {0}, Out_du[maxN] = {0}, tot = 0, root[maxN];
inline int fid(int x) { return x == root[x] ? x : root[x] = fid(root[x]); }
char s[maxN][4], ch[maxN][2];
string tmp;
unordered_map<string, int> Hash_mp;
inline int Hash_id(char fir, char sec)
{
    tmp.clear(); tmp += fir; tmp += sec;
    if(Hash_mp[tmp]) return Hash_mp[tmp];
    else
    {
        ch[++tot][0] = fir; ch[tot][1] = sec;
        return Hash_mp[tmp] = tot;
    }
}
int head[maxN], cnt;
struct Eddge
{
    int nex, to;
    Eddge(int a=-1, int b=0):nex(a), to(b) {}
}edge[maxN << 1];
inline void addEddge(int u, int v) { edge[cnt] = Eddge(head[u], v); head[u] = cnt++; }
stack<char> ans;
stack<int> S;
void dfs(int st)
{
    S.push(st);
    int u, v;
    while(!S.empty())
    {
        u = S.top();
        if(~head[u])
        {
            v = edge[head[u]].to;
            head[u] = edge[head[u]].nex;
            S.push(v);
        }
        else
        {
            ans.push(ch[u][1]);
            S.pop();
        }
    }
}
inline void init()
{
    tot = 0;
    for(int i=0; i<=(N << 1); i++)
    {
        head[i] = -1;
        root[i] = i;
    }
}
int main()
{
    scanf("%d", &N);
    init();
    for(int i=1, u, v, fu, fv; i<=N; i++)
    {
        scanf("%s", s[i]);
        u = Hash_id(s[i][0], s[i][1]); v = Hash_id(s[i][1], s[i][2]);
        Out_du[u]++; In_du[v]++;
        addEddge(u, v);
        fu = fid(u); fv = fid(v);
        if(fu ^ fv) root[fu] = fv;
    }
    int KK = 0;
    for(int i=1; i<=tot; i++) KK += (i == fid(i));
    if(KK ^ 1) { printf("NO\n"); return 0; }
    bool flag = true;
    int st = 0, nono = 0;
    for(int i=1; i<=tot; i++)
    {
        if(In_du[i] == Out_du[i]) continue;
        if(Out_du[i] - In_du[i] == 1)
        {
            if(st)
            {
                flag = false;
                break;
            }
            else st = i;
        }
        else if(Out_du[i] - In_du[i] == -1)
        {
            if(++nono > 1) { flag = false; break; }
        }
        else { flag = false; break; }
    }
    if(!flag) { printf("NO\n"); return 0; }
    if(!st) st = 1; //全相同情况
    dfs(st);
    ans.push(ch[st][0]);
    printf("YES\n");
    while(!ans.empty())
    {
        printf("%c", ans.top());
        ans.pop();
    }
    printf("\n");
    return 0;
}

 

E. Arthur and Brackets

  一道括号匹配问题。这道题可以直接dfs去跑，当然时间上慢得多了。这里有一个贪心的策略。

  我们似乎应当去尽可能的先满足后面的条件，就譬如说，我们发现，如果栈顶对应的那个“L～R”，它所对应的位置加上至少的L长度，还是不足以抵达目前的位置的话，我们当然是还不能放它进去了，如果说它+R又小于了目前为止，当然这是违法的。其次，如果现在它就在这个范围内，我们是可以放入的。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <unordered_map>
#include <unordered_set>
#define _ABS(x, y) ( x > y ? (x - y) : (y - x) )
#define lowbit(x) ( x&( -x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f
#define efs 1e-7
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
#define MP(a, b) make_pair(a, b)
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 605;
int N, l[maxN], r[maxN], cnt, pos[maxN];
char ans[maxN << 1];
stack<int> st;
int main()
{
    scanf("%d", &N);
    for(int i=1; i<=N; i++) scanf("%d%d", &l[i], &r[i]);
    bool flag = true;
    for(int i=1, u; i<=N; i++)
    {
        st.push(i);
        ans[cnt++] = '(';
        pos[i] = cnt - 1;
        while(!st.empty())
        {
            u = st.top();
            if(pos[u] + l[u] > cnt)
            {
                break;
            }
            if(pos[u] + r[u] < cnt)
            {
                flag = false;
                break;
            }
            ans[cnt++] = ')';
            st.pop();
        }
    }
    if(!flag || cnt < 2 * N) printf("IMPOSSIBLE\n");
    else printf("%s\n", ans);

    return 0;
}

 

Wuliwuliii
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
2018-7-13 ACM 专项刷题 栈 + 队列 + 树状数组
FrozenAllen的博客
07-14 750
写的有些久，拖到7-14号凌晨才写完，因为我自己也在慢慢理解中，还是要多做题，做的题越多，理解越深刻。 1. 栈： stack是一种先进入的元素后弹出的数据结构。 有一种常见的栈的应用就是检查括号匹配与否。 对应题目及题解链接：https://blog.csdn.net/ericgipsy/article/details/79980874 2.队列与优先队列：     &lt;队列&g...
CodeForces - 264A - Escape from Stones（栈和队列的应用）
Steve·Curcy
11-14 194
Squirrel Liss lived in a forest peacefully, but unexpected trouble happens. Stones fall from a mountain. Initially Squirrel Liss occupies an interval [0, 1]. Next, n stones will fall and Liss will esc...
排座位
najiuzheyangbaacm的博客
06-26 857
在角色巴士中有n排座位，每排都有2个座位。 第i排的两个座位的宽度均为w i厘米。 没有相同宽度的座椅。 公共汽车最初是空的。 每个2n站都会有一位乘客进入巴士。 有两种类型的乘客： 一个内向者总是选择两个座位都没人的一排。 在这些排中，他选择座位宽度最小的，并占据了其中的一个座位;一个外向型的人总是选择有人的一排。 在这些排中，他选择了座位宽度最大的那个，并占据了空位。 你会得到每排座位的宽度和...
Codeforces Round #288 (Div. 2) E. Arthur and Brackets · 贪心
Yubing792289314的博客
04-03 135
题解 题意：告诉你n个左括号到它匹配的右括号的距离的范围区间，问是否存在合法的匹配的括号序列，如果有，需输出原序 括号序列，优先想到栈，优先解决栈顶的元素更有利于匹配上每一对括号 代码 #include <bits/stdc++.h> using namespace std; const int N = 1e6 + 10; int a[N], l[N], r[N]; char ...
Codeforces Round #288 (Div. 2) ABCDE
weixin_34192816的博客
03-17 91
A题 1 #include <iostream> 2 #include <cstdio> 3 #include <cstring> 4 #include <algorithm> 5 #include <cmath> 6 #include <vector> 7 #include <map...
Codeforces Round #723 (Div. 2).md
10-13
Codeforces Round #723 (Div. 2).md
Codeforces Round #627 (Div. 3) B. Yet Another Palindrome Problem
01-03
就是把所有相等的数放到一个vector里，如果他出现大于2次，看最远的间距是否大于2即可，找到一个就可以 代码： #include #include #include #include #include #include #include #include #include #include #...
Codeforces Round #627 (Div. 3) C. Frog Jumps（思维）
01-20
传送门 题意： 开始位置在0，问能否跳到n+1位置 每步只能跳d 在1——n每个位置有方向，L,R，求d的最小值 思路： 只用找相邻两个R之间的最大值即可 代码： #include #include ...typedef long long l
Codeforces Round #479 (Div. 3) E. Cyclic Components
01-03
E. Cyclic Components 题目链接-E. Cyclic Components 题目大意 给你nnn个点和mmm条边，求所构成图中单圈环的个数 ...并查集并查集并查集 很明显单圈环每个点的度都为222，所以我们可以用数组cnt[]记录每个点的度，...
Codeforces Round #628 (Div. 2)
01-03
给两两节点放一个数字（0~n-2 唯一） 给你一棵树，求所有任意两节点相连的路以外的路上的数字的最小值最小 思路 构造 若一个点连了三条边及以上，则这个点的边从最小值开始赋值。其他边从最大点开始赋值。 证明：一...
贪心(Stack/优先队列)-Bus of Characters - CodeForces - 982B
njuptACMcxk的博客
03-20 158
STL(Stack)-Bus of Characters - CodeForces - 982B 题意： n排座位，每排长度为wi且有两个座位。有2n个乘客依次上车，乘客分为两种类型： ′0′类乘客会选择“没人坐”且长度尽量小的一排就坐，′1′乘客会优先选择“有人坐”且长度尽量大的一排就坐。根据乘客序列输出乘客依次就坐所在排列的序号。′0′与′1′的数量相同，且输入保证′0′和′1′都有...
Codeforces Round #288 (Div. 2) A,B,C,D,E
I am a slow walker, but I never walk backwards!
01-29 1047
A:一个一个点向图里面加，判断其所在的位置与其他的点是否可以构成小矩形就可以了。 B：贪心，如果前面的偶数有比他小的就找到一个最靠前的交换，如果前面的偶数都比它小，就找一个最靠后的交换。 C：贪心，把蜡烛尽可能的放在恶魔，来之前，这样可以充分利用蜡烛的时间，模拟一下，不停地向前方就可以了。如果蜡烛时间小于需要的数目，一定不可以。 const int maxn = 2010; int vi
Codeforces Round #288 (Div. 2)
wcr1996的专栏
01-30 1352
学长让去做CF的题，就把前几天的那场做了两道。 508A - Pasha and Pixels： 给出n*m的像素，每次选一块，变成黑色，判断有没有出现2*2的黑像素，输出是第几次出现的。 思路很简单，点一个判断一次就好了。 一开始用关了流同步的cin和cout，运行140ms，后来换scanf和printf，运行46ms，差了3倍多。原本以为关掉同步之后差不了多少，没想到差这么多。 508B - Anton and currency you all know： 输入一个奇数，输出交换两位后最大的偶数，没有
Codeforces Round #288 (Div. 2) 总结
小马的博客
01-25 372
A. Pasha and Pixels time limit per test 2 seconds memory limit per test 256 megabytes input standard input output standard output Pasha loves his phone and also putting
总结之栈和队列
Thinking
01-23 435
栈在实际上有很多应用，比如说语法检查，判断平衡符号，函数的调用等等。 下面写了两个栈使用的例子。 1.Valid parenheses. http://blog.csdn.net/chencheng126/article/details/40107109 2.Longest valid parentheses. http://blog.csdn.net/chencheng126/
【Codeforces 797 C. Minimal string 】队列+栈
我是谁 --- 卡比兽
07-12 209
CF 797C • 给定长度为n的小写字母字符串s，及空串t, u，两种操作 • 1. 将s的第一个字符加到t的末尾 • 2. 将t的最后一个字符加到u的末尾 • 求字典序最小的字符串u (长度必须为n，即s, t最后为空串) • 1 ≤ n ≤ 1e5 这道题骚在 s 是一个队列 t 是一个栈 那么只要你s中最小的字符比栈的元素小于 那么肯定是队列进栈 否则栈去 t 中 /* if yo...
Codeforces Round #288 (Div. 2) D. Tanya and Password （有向图欧拉路）
_Griefs
08-24 142
题目链接 题面： 题意： 给定 n 个长度为 3 的串，问能不能由这 n 个串组成一个长度为 n+2 的串。 题解： 这类题目好像之前做过，就是形成一张图，然后判定是不是有欧拉路。 因为是 n 个长度为 3 的串，形成一个长度为 n+2 的串，那么中间的重叠的地方一定是某个串的后两位和某个串的前两位。譬如说 abb bbc 形成长度为4的串，一定是 abbc。 我们可以由每个串的前两位向后两位连边。然后判断是否存在欧拉路径。 若存在欧拉路径，则说明可以一笔画画完整张图，则说明可以形成一个n+2长度的串
Codeforces548D Mike and Feet 数据结构+单调栈+优先队列
fans_ac的博客
07-21 276
D - Mike and Feet Time Limit:1000MS    Memory Limit:262144KB    64bit IO Format:%I64d & %I64u SubmitStatus Description Mike is the president of country What-The-Fatherland. There are n b
Voting【Codeforces 1251 E1 && E2】【贪心】
既然弱小，就只顾变强就是了
10-25 637
Educational Codeforces Round 75 (Rated for Div. 2) E2 Now elections are held in Berland and you want to win them. More precisely, you want everyone to vote for you. There are????nvoters, and two ways...
codeforces round #772 (div. 2)
最新发布
03-16
好的，Codeforces Round #772 (Div. 2) 是一场由Codeforces主办的在线编程竞赛。 该比赛的比赛链接为：https://codeforces.com/contest/772。 该比赛分为两个级别：Div.1和Div.2。 Div. 1级别通常比Div. 2级别更...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Wuliwuliii

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

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

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

打赏作者

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

抵扣说明：

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

余额充值