AtCoder Beginner Contest 277

A - ^{-1}

Problem Statement

You are given a sequence $P$ that is a permutation of $(1,2,\dots ,N)$, and an integer $X$. The $i$-th term of $P$ has a value of $P_i$. Print $k$ such that $P_k=X$.

Constraints

• $1\le N\le 100$
• $1\le X\le N$
• $P$ is a permutation of $(1,2,\dots ,N)$.
• All values in the input are integers.

Input

The input is given from Standard Input in the following format:

$N$ $X$ $P_1$ $P_2$ $\dots$ $P_N$

Output

Print the answer.

Sample Input 1

4 3
2 3 1 4

Sample Output 1

2

We have $P=(2,3,1,4)$, so $P_2=3$. Thus, you should print $2$.

Sample Input 2

5 2
3 5 1 4 2

Sample Output 2

5

Sample Input 3

6 6
1 2 3 4 5 6

Sample Output 3

6

题目大意：

给定一个 $1\sim n$ 的排列 $P$，以及一个数字 $X$（$1\le X\le n$）。求排列中，第几位的元素为$X$。

分析：

$N$只有100，直接从前向后查找。

#include<bits/stdc++.h>
using namespace std;
int n,x,a;
int main(){
cin>>n>>x;
for(int i=1;i<=n;++i){
cin>>a;
if(a==x){
cout<<i<<endl;
break;
}
}
return 0;
}

B - Playing Cards Validation

Problem Statement

You are given $N$ strings, each of length $2$, consisting of uppercase English letters and digits. The $i$-th string is $S_i$.
Determine whether the following three conditions are all satisfied.
・For every string, the first character is one of H, D, C, and S.
・For every string, the second character is one of A, 2, 3, 4, 5, 6, 7, 8, 9, T, J, Q, K.
・All strings are pairwise different. That is, if $i\ne j$, then $S_i\ne S_j$​.

Constraints

• $1\le N\le 52$
• $S_i$ is a string of length $2$ consisting of uppercase English letters and digits.

Input

The input is given from Standard Input in the following format:

$N$ $S_1$ $S_2$ $⋮$ $S_N$

Output

If the three conditions are all satisfied, print Yes; otherwise, print No.

Sample Input 1

4
H3
DA
D3
SK

Sample Output 1

Yes

One can verify that the three conditions are all satisfied.

Sample Input 2

5
H3
DA
CK
H3
S7

Sample Output 2

No

Both $S_1$ and $S_4$ are H3, violating the third condition.

Sample Input 3

4
3H
AD
3D
KS

Sample Output 3

No

Sample Input 4

5
00
AA
XX
YY
ZZ

Sample Output 4

No

题目大意：

有$N$个长度为$2$的字符串，如果满足：

各字符串第一个字符为H,D,C或S，且第二个字符为A 2~9 或T J Q K，并且都不相同。

则输出Yes。否则输出No。

分析：

硬核模拟。

#include<bits/stdc++.h>
using namespace std;
int n,len=0;
string s,st[53];//st数组记录出现过了哪些字符串
int main(){
cin>>n;
bool flag=true;
for(int i=1;i<=n;++i){
cin>>s;
for(int j=1;j<=len;++j)
if(st[j]==s){//重复
flag=false;
break;
}
if(!flag)
break;
char c=s[0];
if(c=='H'||c=='D'||c=='C'||c=='S'){
char x=s[1];
if(!(x=='A'||'2'<=x&&x<='9'||x=='T'||x=='J'||x=='Q'||x=='K'))
flag=false;//不合题意
}else//不合题意
flag=false;
if(!flag)
break;
st[++len]=s;
}if(flag)
cout<<"Yes"<<endl;
else
cout<<"No"<<endl;
return 0;
}

C - Ladder Takahashi

Problem Statement

There is a $10^9$-story building with $N$ ladders.
Takahashi, who is on the $1$-st (lowest) floor, wants to reach the highest floor possible by using ladders (possibly none).
The ladders are numbered from $1$ to $N$, and ladder $i$ connects the $A_i$-th and $B_i$-th floors. One can use ladder $i$ in either direction to move from the $A_i$-th floor to the $B_i$​-th floor or vice versa, but not between other floors.
Takahashi can freely move within the same floor, but cannot move between floors without using ladders.
What is the highest floor Takahashi can reach?

Constraints

• $1\le N\le 2\times 10^5$
• $1\le A_i,B_i\le 10^9$
• $A_i\ne B_i$
• All values in the input are integers.

Input

The input is given from Standard Input in the following format:

$N$ $A_1$ $B_1$ $A_2$ $B_2$ $\dots$ $A_N$ $B_N$

Output

Print an integer representing the answer.

Sample Input 1

4
1 4
4 3
4 10
8 3

Sample Output 1

10

He can reach the $10$-th floor by using ladder $1$ to get to the $4$-th floor and then ladder $3$ to get to the $10$-th floor.

Sample Input 2

6
1 3
1 5
1 12
3 5
3 12
5 12

Sample Output 2

12

Sample Input 3

3
500000000 600000000
600000000 700000000
700000000 800000000

Sample Output 3

1

He may be unable to move between floors.

题目大意：

有一座很高的楼，Takahashi现在在第一层。

有 $n$ 个梯子，每个梯子连接第 $a_i$ 层与 $b_i$ 层。梯子是双向的。

请你求出Takahashi能到达的最高楼层。

分析：

• $1\le N\le 2\times 10^5$
• $1\le A_i,B_i\le 10^9$
• $A_i\ne B_i$

我们可以看到这个数据范围非常的阴间，普通的dp是开不了这么大的，但是N只有2e5，所以可以用离散实现。

#include<bits/stdc++.h>
using namespace std;
int n;
map<int,vector<int> >g;//存图
map<int,int>dp;//first为楼层,second为first楼层能到达的最高层
int dfs(int fl){
if(g.count(fl)==0)
return fl;
if(dp.count(fl)==1)
return dp[fl];
int h=fl;
dp[fl]=fl;//次此处必须把当前楼层开出来，否则遇到1~2~3~1一类的情况会死循环
for(int i=0;i<g[fl].size();++i)//这里的g[fl].size()被at的编译器警告了
h=max(h,dfs(g[fl][i]));
return dp[fl]=h;//记忆化返回
}
int main(){
cin>>n;
int a,b;
for(int i=1;i<=n;++i){
cin>>a>>b;
g[a].push_back(b);
g[b].push_back(a);
}cout<<dfs(1)<<endl;//输出
return 0;
}

D - Takahashi’s Solitaire

Problem Statement

Takahashi has $N$ cards in his hand. For $i=1,2,\dots ,N$, the $i$-th card has an non-negative integer $A_i$ written on it.

First, Takahashi will freely choose a card from his hand and put it on a table. Then, he will repeat the following operation as many times as he wants (possibly zero).

• Let $X$ be the integer written on the last card put on the table. If his hand contains cards with the integer $X$ or the integer $(X+1)\mathrm{m}\mathrm{o}\mathrm{d}M$ written on them, freely choose one of those cards and put it on the table. Here, $(X+1)\mathrm{m}\mathrm{o}\mathrm{d}M$ denotes the remainder when $(X+1)$ is divided by $M$.

Print the smallest possible sum of the integers written on the cards that end up remaining in his hand.

Constraints

• $1\le N\le 2\times 10^5$
• $2\le M\le 10^9$
• $0\le A_i<M$
• All values in the input are integers.

Input

The input is given from Standard Input in the following format:

$N$ $M$ $A_1$ $A_2$ $\dots$ $A_N$

Output

Print the answer.

Sample Input 1

9 7
3 0 2 5 5 3 0 6 3

Sample Output 1

11

Assume that he first puts the fourth card ($5$ is written) on the table and then performs the following.

• Put the fifth card ($5$ is written) on the table.
• Put the eighth card ($6$ is written) on the table.
• Put the second card ($0$ is written) on the table.
• Put the seventh card ($0$ is written) on the table.

Then, the first, third, sixth, and ninth cards will end up remaining in his hand, and the sum of the integers on those cards is $3+2+3+3=11$. This is the minimum possible sum of the integers written on the cards that end up remaining in his hand.

Sample Input 2

1 10
4

Sample Output 2

0

Sample Input 3

20 20
18 16 15 9 8 8 17 1 3 17 11 9 12 11 7 3 2 14 3 12

Sample Output 3

99

题目大意：

给定 $n$ 张牌，每张牌上有一个数字 $a_i$。

你要先选一张牌放在桌子上。假设当前最后一张放置的牌为 $X$，接下来，你每次只能放写着 $X$ 或 $(X+1)\mathrm{m}\mathrm{o}\mathrm{d}M$ 的牌。

一直操作下去。你需要让你手上剩下的牌的总和最小。

分析：

寻找一个连续自然数列，使得乘积最大，注意判环。

#include<bits/stdc++.h>
using namespace std;
#define MAXN 200010
#define ll long long
int n,m,a[MAXN],ex[MAXN],len=0;
ll dp[MAXN],all=0;//ll
map<int,ll>vh;//second用ll是为了省去下面的强类型转换
int main(){
cin>>n>>m;
for(int i=1;i<=n;++i){
cin>>a[i];
all+=a[i];//all表示所有数之和
if(vh.count(a[i])==0)
ex[++len]=a[i];//ex数组存放所有出现的数字
++vh[a[i]];//vh存放a[i]出现的次数
}sort(ex+1,ex+1+len);
dp[len]=ex[len]*vh[ex[len]];//dp[i]表示在数字ex[i]即之后，连续的ex[i]*vh[ex[i]]之和
for(int i=len-1;i>=1;--i){
if(ex[i+1]-ex[i]==1)
dp[i]=dp[i+1];
dp[i]+=ex[i]*vh[ex[i]];
}ll maxx=0;//maxx表示放到桌子上的最大总数
if(ex[len]==m-1&&ex[1]==0){//首尾相连，m-1的下一个是0
if(len==m)//1~m都出现了
maxx=all;
else{
dp[len]+=dp[1];
for(int i=len-1;i>=1;--i){
if(ex[i+1]-ex[i]!=1)
break;
dp[i]+=dp[1];
}//处理环
}
}for(int i=1;i<=len;++i)
maxx=max(maxx,dp[i]);//在所有dp之中找一个最大值
cout<<all-maxx<<endl;
return 0;
}

E - Crystal Switches

Problem Statement

You are given an undirected graph consisting of $N$ vertices and $M$ edges.
For $i=1,2,\dots ,M$, the $i$-th edge is an undirected edge connecting vertex $u_i$ and $v_i$ that is initially passable if $a_i=1$ and initially impassable if $a_i=0$. Additionally, there are switches on $K$ of the vertices: vertex $s_1$, vertex $s_2$, $\dots \dots$, vertex $s_K$.

Takahashi is initially on vertex $1$, and will repeat performing one of the two actions below, Move or Hit Switch, which he may choose each time, as many times as he wants.

• Move: Choose a vertex adjacent to the vertex he is currently on via an edge, and move to that vertex.
• Hit Switch: If there is a switch on the vertex he is currently on, hit it. This will invert the passability of every edge in the graph. That is, a passable edge will become impassable, and vice versa.

Determine whether Takahashi can reach vertex $N$, and if he can, print the minimum possible number of times he performs Move before reaching vertex $N$.

Constraints

• $2\le N\le 2\times 10^5$
• $1\le M\le 2\times 10^5$
• $0\le K\le N$
• $1\le u_i,v_i\le N$
• $u_i\ne v_i$
• a i   ∈   {   0 ,   1 } a_i in lbrace 0, 1rbrace ai​ ∈ { 0, 1}
• $1\le s_1<s_2<\cdots <s_K\le N$

Input

The input is given from Standard Input in the following format:

$N$ $M$ $K$ $u_1$ $v_1$ $a_1$ $u_2$ $v_2$ $a_2$ $⋮$ $u_M$ $v_M$ $a_M$ $s_1$ $s_2$ $\dots$ $s_K$

Output

If Takahashi cannot reach vertex $N$, print $-1$; if he can, print the minimum possible number of times he performs Move before reaching vertex $N$.

Sample Input 1

5 5 2
1 3 0
2 3 1
5 4 1
2 1 1
1 4 0
3 4

Sample Output 1

5

Takahashi can reach vertex $N$ as follows.

• Move from vertex $1$ to vertex $2$.
• Move from vertex $2$ to vertex $3$.
• Hit the switch on vertex $3$. This inverts the passability of every edge in the graph.
• Move from vertex $3$ to vertex $1$.
• Move from vertex $1$ to vertex $4$.
• Hit the switch on vertex 4. This again inverts the passability of every edge in the graph.
• Move from vertex $4$ to vertex $5$.

Here, Move is performed five times, which is the minimum possible number.

Sample Input 2

4 4 2
4 3 0
1 2 1
1 2 0
2 1 1
2 4

Sample Output 2

-1

The given graph may be disconnected or contain multi-edges. In this sample input, there is no way for Takahashi to reach vertex $N$, so you should print $-1$.

题目大意：

给定一张 $n$ 个点 $m$ 条边的无向图。每条边有一个权值 w ∈ { 0 , 1 } w in {0, 1} w∈{0,1}。$w=0$ 表示这条边无法通过，$w=1$ 则可以通过。

有 $k$ 个点上面有按钮 $s_i$。

你现在位于 $1$ 号点。每次，你可以做两件事情中的一件：

1. 移动。移到相邻的一个点上，注意这条边一定是可以通行的。
2. 按开关。此时，全部路的边权取反。即：$w=0$ 变成 $1$，$w=1$ 变成 $0$。

请问你是否能够到达 $n$ 号点。如果可以，求出最少移动次数。

【输入格式】

第一行三个数 $n,m,k$。

接下来 $m$ 行，每行三个数 $u_i,v_i,w_i$表示一条连接 $u_i$ 与 $v_i$ 的边。

最后一行 $k$ 个数，表示按钮的位置。

【输出格式】

如果无法到达，输出 $-1$。否则输出最少移动次数。

【数据范围】

$2\le n\le 2\times 10^5$

$1\le m\le 2\times 10^5$

$1\le k\le n$

保证 $1\le u_i,v_i\le n$，且 $u_i\ne v_i$。

保证 $1\le s_1<s_2<\cdots <s_k\le n$。

分析：

可以看到，按一次按钮，边权取反，这个按钮是两个不同图的通路，则样例1的图相当于是：

$$\begin{gathered} A\sim C=1 \\ 2\sim 3=1 \\ 5\sim 4=1 \\ 2\sim 1=1 \\ A\sim D=1 \\ 3\sim C=0 \\ 4\sim D=0 \end{gathered}$$

普通SPFA

SPFA会被额外数据hack掉， 但分是给了的。

#include<bits/stdc++.h>
using namespace std;
#define MAXN 400010
int n,m,k;
struct nod{
int to;//邻点
bool a;//权值
nod(int _t=0,bool _a=0):to(_t),a(_a){}
};
vector<nod>g[MAXN];//+MAXN/2 是另外一个图（即上文的大写字母部分）
int spfa(int fir,int ned){
int dis[MAXN];
bool vh[MAXN];
queue<int>spf;
memset(dis,63,sizeof(dis));
memset(vh,false,sizeof(vh));
dis[fir]=0;
spf.push(fir);
vh[fir]=true;
while(!spf.empty()){
int u=spf.front();
spf.pop();
vh[u]=false;
for(int i=0;i<g[u].size();++i){
int v=g[u][i].to;
bool a=g[u][i].a;
if(dis[u]+a<dis[v]){
dis[v]=dis[u]+a;
if(!vh[v]){
spf.push(v);
vh[v]=true;
}
}
}
}return min(dis[ned],dis[ned+MAXN/2]);//只要到达N节点即可，不考虑状态
}
int main(){
cin>>n>>m>>k;
int u,v,a;
for(int i=1;i<=m;++i){
cin>>u>>v>>a;
if(a==1){
g[u].push_back(nod(v,1));
g[v].push_back(nod(u,1));
}else{
g[u+MAXN/2].push_back(nod(v+MAXN/2,1));
g[v+MAXN/2].push_back(nod(u+MAXN/2,1));
}//存图
}for(int i=1;i<=k;++i){
cin>>u;
g[u].push_back(nod(u+MAXN/2,0));
g[u+MAXN/2].push_back(nod(u,0));
}int x=spfa(1,n);
if(x==1061109567)//这是memset后的结果，没变则表示无法到达
cout<<-1<<endl;
else
cout<<x<<endl;
return 0;
}

堆优化SPFA

每次选择dis值最小的那个节点扩展，跟dijkstra类似。 （别问为什么不写dijk，问就是没调出来）

#include<bits/stdc++.h>
using namespace std;
#define MAXN 400010
int n,m,k,dis[MAXN];
struct nod{
int to;
bool a;
nod(int _t=0,bool _a=0):to(_t),a(_a){}
};
vector<nod>g[MAXN];
struct cmp{
bool operator()(int a,int b){
return dis[a]>dis[b]||dis[a]==dis[b]&&a<b;
}
};//这里的小根堆是问同学的，应该算是板子
int spfa(int fir,int ned){
bool vh[MAXN];
priority_queue<int,vector<int>,cmp>spf;
memset(dis,63,sizeof(dis));
memset(vh,false,sizeof(vh));
dis[fir]=0;
spf.push(fir);
vh[fir]=true;
while(!spf.empty()){
int u=spf.top();//每次取dis值最小的一个扩展，扩展得到的dis值一定是最优的，只入一次队
spf.pop();
vh[u]=false;
for(int i=0;i<g[u].size();++i){
int v=g[u][i].to;
bool a=g[u][i].a;
if(dis[u]+a<dis[v]){
dis[v]=dis[u]+a;
if(!vh[v]){
spf.push(v);
vh[v]=true;
}
}
}
}return min(dis[ned],dis[ned+MAXN/2]);
}
int main(){
cin>>n>>m>>k;
int u,v,a;
for(int i=1;i<=m;++i){
cin>>u>>v>>a;
if(a==1){
g[u].push_back(nod(v,1));
g[v].push_back(nod(u,1));
}else{
g[u+MAXN/2].push_back(nod(v+MAXN/2,1));
g[v+MAXN/2].push_back(nod(u+MAXN/2,1));
}
}for(int i=1;i<=k;++i){
cin>>u;
g[u].push_back(nod(u+MAXN/2,0));
g[u+MAXN/2].push_back(nod(u,0));
}int x=spfa(1,n);
if(x==1061109567)
cout<<-1<<endl;
else
cout<<x<<endl;
return 0;
}

F - Sorting a Matrix

Problem Statement

You are given a matrix $A$ whose elements are non-negative integers. For a pair of integers $(i,j)$ such that $1\le i\le H$ and $1\le j\le W$, let $A_{i,j}$ denote the element at the $i$-th row and $j$-th column of $A$.

Let us perform the following procedure on $A$.

• First, replace each element of $A$ that is $0$ with an arbitrary positive integer (if multiple elements are $0$, they may be replaced with different positive integers).
• Then, repeat performing one of the two operations below, which may be chosen each time, as many times as desired (possibly zero).
  • Choose a pair of integers $(i,j)$ such that $1\le i<j\le H$ and swap the $i$-th and $j$-th rows of $A$.
  • Choose a pair of integers $(i,j)$ such that $1\le i<j\le W$ and swap the $i$-th and $j$-th columns of $A$.

Determine whether $A$ can be made to satisfy the following condition.

• $A_{1,1}\le A_{1,2}\le \cdots \le A_{1,W}\le A_{2,1}\le A_{2,2}\le \cdots \le A_{2,W}\le A_{3,1}\le \cdots \le A_{H,1}\le A_{H,2}\le \cdots \le A_{H,W}$

• In other words, for every two pairs of integers $(i,j)$ and $(i^{\prime },j^{\prime })$ such that $1\le i,i^{\prime }\le H$ and $1\le j,j^{\prime }\le W$, both of the following conditions are satisfied.

  • If$i<i^{\prime }$ ,then$A_{i,j}\le A_{i^{\prime },j^{\prime }}$
    • If $i=i^{\prime }$ and $j<j^{\prime }$ ,then $A_{i,j}\le A_{i^{\prime },j^{\prime }}$

Constraints

• $2\le H,W$
• $H\times W\le 10^6$
• $0\le A_{i,j}\le H\times W$
• All values in the input are integers.

Input

The input is given from Standard Input in the following format:

$H$ $W$ $A_{1,1}$ $A_{1,2}$ $\dots$ $A_{1,W}$ $A_{2,1}$ $A_{2,2}$ $\dots$ $A_{2,W}$ $⋮$ $A_{H,1}$ $A_{H,2}$ $\dots$ $A_{H,W}$

Output

If $A$ can be made to satisfy the condition in the problem statement, print Yes; otherwise, print No.

Sample Input 1

3 3
9 6 0
0 4 0
3 0 3

Sample Output 1

Yes

One can perform the operations as follows to make $A$ satisfy the condition in the problem statement, so you should print Yes.

• First, replace the elements of $A$ that are 00, as shown below:

9 6 8
5 4 4
3 1 3

• Swap the second and third columns. Then, $A$ becomes:

9 8 6
5 4 4
3 3 1

• Swap the first and third rows. Then, $A$ becomes:

3 3 1
5 4 4
9 8 6

• Swap the first and third columns. Then, $A$ becomes the following and satisfies the condition in the problem statement.

1 3 3
4 4 5
6 8 9

Sample Input 2

2 2
2 1
1 2

Sample Output 2

No

There is no way to perform the operations to make $A$ satisfy the condition in the problem statement, so you should print No.

题目大意：

给一个$H$行$W$列的矩阵$A$，所有元素都是自然数，可以把$0$改成任意正整数，也可以交换任意次任意行任意列，问是否有一种做法能使得 $A_{1,1}\le A_{1,2}\le \cdots \le A_{1,W}\le A_{2,1}\le A_{2,2}\le \cdots \le A_{2,W}\le A_{3,1}\le \cdots \le A_{H,1}\le A_{H,2}\le \cdots \le A_{H,W}$，能则输出Yes，否则输出No。

分析：

骗分算法：

输出Yes有34个点，No有37个点

错误算法：

运用必要且不充分条件。

单看行，假设每一行的每个元素都是可以任意交换而不影响其他行的，那么有以下进阶骗分代码。

实测有61个点AC，10个点WA。

#include<bits/stdc++.h>
using namespace std;
#define MAXN 1000010
int h,w;
struct nod{
int b=-1,s=INT_MAX;
}a[MAXN];
bool cmp(nod a,nod b){
return a.s<b.s||a.s==b.s&&a.b<b.b;
}
int main(){
cin>>h>>w;
int el;
for(int i=1;i<=h;++i){
for(int j=1;j<=w;++j){
cin>>el;
if(el==0)
continue;
a[i].b=max(a[i].b,el);
a[i].s=min(a[i].s,el);
}if(a[i].b==-1)
a[i].s=0,a[i].b=0;//找每一行的最大最小值
}sort(a+1,a+1+h,cmp);//按最小值升序排序
bool flag=true;
for(int i=2;i<=h;++i)
if(a[i-1].b>a[i].s){//如果上一行的最大值比下一行的最小值大，那么不可能
flag=false;
break;
}
if(flag)
cout<<"Yes"<<endl;
else
cout<<"No"<<endl;
return 0;
}

标算不会（

标算看蒙了（（（

最后

以上就是呆萌白猫为你收集整理的AtCoder Beginner Contest 277AtCoder Beginner Contest 277的全部内容，希望文章能够帮你解决AtCoder Beginner Contest 277AtCoder Beginner Contest 277所遇到的程序开发问题。

如果觉得靠谱客网站的内容还不错，欢迎将靠谱客网站推荐给程序员好友。