AtCoder 题目集1

AtCoder 题目集1

这是一个AT个人刷题总结的开始，感觉确实应该做一做这种总结，如果只是不断的刷题，感觉貌似也没有什么意思，还不如时常适当的回望一下过去的好题。希望能一直做下去吧。

update(22.12.14): AT赛后总结归为另外一栏，此处为过去AT题目的记录。

总结了一些比较有趣或者有思维的题(对于我这个菜鸡)。

编号(NO.)	题目	难度	类型
1	ARC060E	2154	倍增
2	ABC089D	1220	思维，前缀和
3	ABC087D	1452	思维，DFS
4	ABC277D	873	思维
5	ABC277E	1183	状态图，01BFS
6	ABC118D	1657	DP
7	ABC276E	1058	BFS，思维变形
8	ABC078D	1550	博弈论，思维
9	ABC013C	1692	思维
10	ABC143E	1695	思维，最短路

---

NO.1 ARC060E

倍增板题。

const int maxn=1e5+5;

int n,L,q;
int x[maxn],f[maxn][20],_2[20];

inline void Pre(){
	
	for(int i=1;i<n;++i){
		int l=i+1,r=n;
		while(l<r){
			int mid=(l+r+1)>>1;
			if(x[mid]-x[i]>L) r=mid-1;
			else l=mid;
		} f[i][0]=l;
	}
	
	_2[0]=1;
	for(int j=1;j<=18;++j){
		_2[j]=(_2[j-1]<<1);
		for(int i=1;i<=n;++i)
			f[i][j]=f[f[i][j-1]][j-1];
	}
} 

inline void solve(int x,int y){
	int res=0;
	for(int i=18;i>=0;--i){
		if(!f[x][i]||f[x][i]>y) continue;
		x=f[x][i];
		res+=_2[i];
	} if(x<y) ++res;
	cout<<res<<'\n';
}

int main(){
//  freopen("E.in","r",stdin);
//  freopen("E.out","w",stdout);
  IOS
  cin>>n;
  for(int i=1;i<=n;++i)
  	cin>>x[i];
  cin>>L>>q;
  
  Pre();
  
	int fo,to;
	while(q--){
  	cin>>fo>>to;
  	if(fo>to) swap(fo,to);
  	solve(fo,to);
	}
  return 0;
}

---

NO.2 ABC089D

思维题，但是没想出来。其实很显然需要一个可以快速统计答案的方法。一开始上来想了下倍增，但是显然麻烦了。可以用一种前缀的思想去做，因为变量值为 \(d\) ，所以可以预处理出从最小值到某个数的步数，然后用前缀思想就好了。

const int maxn=1e5+5;

int n,m,d,q;
int f[maxn],x[maxn],y[maxn];

int main(){
//  freopen("D.in","r",stdin);
//  freopen("D.out","w",stdout);
  IOS
  cin>>n>>m>>d; int p;
  for(int i=1;i<=n;++i)
  	for(int j=1;j<=m;++j)
  		cin>>p,x[p]=i,y[p]=j;
	
	for(int i=d+1;i<=n*m;++i)
		f[i]=f[i-d]+fabs(x[i]-x[i-d])+fabs(y[i]-y[i-d]);
	
	cin>>q;
	int l,r;
	while(q--){
		cin>>l>>r;
		cout<<f[r]-f[l]<<'\n';
	}
  return 0;
}

---

NO.3 ABC087D

这题应该很经典。

思路也比较好想到，对于一对关系，建边就好了，然后跑一边dfs，如果发现其中有一个关系不符合就直接返回false。可能有多个连通块所以要for一遍。

const int maxn=1e5+5;
const int maxm=2e5+5;

int n,m,cnt,head[maxn];
struct Edge{
	int to,nxt,val;
}edge[maxm<<1];

inline void Add(int fo,int to,int val){
	edge[++cnt]={to,head[fo],val};
	head[fo]=cnt;
}

int dis[maxn];
bool vis[maxn];
inline bool dfs(int x,int d){
	vis[x]=true,dis[x]=d;
	for(int i=head[x];i;i=edge[i].nxt){
		int &to=edge[i].to;
		if(vis[to]){
			if(dis[to]!=dis[x]+edge[i].val)
			return false;
		} else if(!dfs(to,d+edge[i].val))
			return false;
	}
	return true;
}

inline void solve(){
	for(int i=1;i<=n;++i)
		if(!vis[i])
			if(!dfs(i,0)){
				cout<<"No\n";
				return ;
			}
	cout<<"Yes\n";
}

int main(){
//  freopen("D.in","r",stdin);
//  freopen("D.out","w",stdout);
  IOS
  cin>>n>>m;
  int fo,to,val;
  for(int i=1;i<=m;++i){
  	cin>>fo>>to>>val;
  	Add(fo,to,val);
  	Add(to,fo,-val);
	}
	solve();
  return 0;
}

---

NO.4 ABC277D

这题...比赛时候一上来就想了一个tarjan缩点，结果很显然，打的很麻烦...又臭又长

const int maxn=2e5+5;
const int maxm=1e6+5;
 
int n,mod,a[maxn],cnt,head[maxn];
map <int,int> mp;
struct Edge{
	int fo,to,nxt;
}edge[maxm];
inline void Add(int fo,int to){
	edge[++cnt]={fo,to,head[fo]};
	head[fo]=cnt;
}
 
bool ins[maxn];
int dfn[maxn],low[maxn],s[maxn],top,belong[maxn],gp;
ll v[maxn];
inline void tj(int x){
	dfn[x]=low[x]=++cnt,s[++top]=x,ins[x]=true;
	for(int i=head[x];i;i=edge[i].nxt){
		int &to=edge[i].to;
		if(!dfn[to]){
			tj(to);
			low[x]=min(low[x],low[to]);
		} else if(ins[to]) low[x]=min(low[x],low[to]);
	}
	
	if(dfn[x]==low[x]){
		int c; ++gp;
		do{
			c=s[top--];
			ins[c]=false;
			belong[c]=gp;
			v[gp]+=a[c];
		} while(top&&c^x);
	}
}
 
int in[maxn];
ll dis[maxn];
inline ll topo(){
	queue<int>q; ll res=0;
	for(int i=1;i<=gp;++i)
		if(!in[i]) q.push(i),dis[i]=v[i];
	
	while(!q.empty()){
		int c=q.front(); q.pop();
		for(int i=head[c];i;i=edge[i].nxt){
			int &to=edge[i].to;
			dis[to]=Max(dis[to],dis[c]+v[to]);
			--in[to]; if(!in[to]) q.push(to);
		}
	}
	for(int i=1;i<=gp;++i) res=Max(res,dis[i]);
	return res;
}
 
ll tot;
inline void solve(){
	for(int i=1;i<=n;++i){
		if(!mp[a[i]])
			mp[a[i]]=i;
	}
	
	for(int i=1;i<=n;++i){
		if(a[i+1]==a[i])
			Add(i,i+1);
		if(mp[(1+a[i])%mod])
			Add(i,mp[(a[i]+1)%mod]);
	}
	
	int m=cnt;
	cnt=0;
	for(int i=1;i<=n;++i)
		if(!dfn[i]){
			top=0;
			tj(i);
		}
		
	cnt=0;
	memset(head,0,sizeof(head));
	for(int i=1;i<=m;++i){
		int x=belong[edge[i].fo],y=belong[edge[i].to];
		if(x^y){
			Add(x,y);
			in[y]+=1;
		}
	}
	cout<<tot-topo()<<'\n';
}
 
int main(){
  IOS
  cin>>n>>mod;
	for(int i=1;i<=n;++i)
		cin>>a[i],tot+=a[i];
	sort(a+1,a+1+n);
	solve();
  return 0;
}

跑了166ms。然而实际上，这题很好做。其实这道题麻烦(对我)主要还是在环那里，然而观察一下很容易(然而我没有)就能发现，其实循环的情况只可能是这样的形式：

\((m-2) \rightarrow (m-1) \rightarrow 0 \rightarrow 1...\)

所以很容易想到先排个序。那么因为给出的数都是小于 \(M\) 的，所以不用担心会有超出 \(M\) 的情况(草，忘了)。所以，开个两倍数组接在后面就完了啊！如果有循环，那就循环呗，最后再特判一下减出来会不会小于0就好了啊(因为如果整个都是个循环，可能会重复计算)！

const int maxn=2e5+5;

bool vis[maxn<<1];
int n,mod,a[maxn<<1];
ll tot;

inline void solve(){
	for(int i=1;i<=n;++i)
		a[i+n]=a[i];
	
	int pos=1; ll res=a[1],ans=0;
	a[n+n+1]=-1;
	while(pos<=n+n+1){
		if(a[pos+1]==a[pos]||a[pos+1]==(a[pos]+1)%mod)
			res+=a[pos+1];
		else
			ans=Max(ans,res),res=a[pos+1];
		++pos;
	}
	cout<<Max(0ll,tot-ans)<<'\n';
	
}

int main(){
//  freopen("D.in","r",stdin);
//  freopen("D.out","w",stdout);
  IOS
  cin>>n>>mod;
	for(int i=1;i<=n;++i)
		cin>>a[i],tot+=a[i];
	sort(a+1,a+1+n);
	solve();
  return 0;
}

---

NO.5 ABC277E

嗯，做这个题时读错题了，虽然好像然并卵，因为我已经摆了。

实际上这个题挺巧妙的(虽然只评了个1200)。

考虑对于给定的图，他按了开关后，所有能走的边都走不脱了，反之。那么再按一次，他的状态又回来了，所以一个图他只有两个状态。容易想到把另一个状态的图建出来，那么对于一个点，如果他想要另一个状态，他就必须按开关才行，所以只有开关点才能连通两个状态作为桥梁。

那么接下来就很容易了，发现是个01BFS，那就B呗。

感觉这题思路还是挺巧妙的...

const int maxn=2e5+5;

int n,m,k,cnt=1,head[maxn<<1],a[maxn<<1];
struct Edge{
	int fo,to,nxt,val;
}edge[maxn<<2];
inline void Add(int fo,int to,int val){
	edge[++cnt]={fo,to,head[fo],val};
	head[fo]=cnt;
}

deque <int> q;
int dis[maxn<<1];
bool vis[maxn<<1];
inline bool bfs_01(int pos){
	memset(dis,0x3f,sizeof(dis));
	q.push_front(pos);
	dis[1]=0;
	while(q.size()){
		int x=q.front(); q.pop_front();
		if(vis[x]) continue;
		vis[x]=true;
		for(int i=head[x];i;i=edge[i].nxt){
			int &to=edge[i].to;
			if(dis[to]>dis[x]+edge[i].val){
				dis[to]=edge[i].val+dis[x];
				if(edge[i].val) q.push_back(to);
				else q.push_front(to);
			}
		}
	}
	
	return vis[n]||vis[n<<1];
}

bool yon[maxn<<1];

inline void solve(){
	F(1,i,1,k){
		Add(a[i],n+a[i],0);
		Add(n+a[i],a[i],0);
	}
	
	if(bfs_01(1))
		cout<<Min(dis[n],dis[n<<1])<<'\n';
	else
		cout<<-1<<'\n';
}

int main(){
//  freopen("E.in","r",stdin);
//  freopen("E.out","w",stdout);
  IOS
  cin>>n>>m>>k;
  int fo,to,val;
	for(int i=1;i<=m;++i){
  	cin>>fo>>to>>val;
  	if(val){
  		Add(fo,to,val);
  		Add(to,fo,val);
		} else{
	  	Add(fo+n,to+n,val^1);
	  	Add(to+n,fo+n,val^1);
		}
	}
	for(int i=1;i<=k;++i)	cin>>a[i];
	solve();
  return 0;
}

---

NO.6 ABC118D

题意翻译:
有n根火柴,m种数字,数字1,2,3,4,5,6,7,8,9分别需要2,5,5,4,5,6,3,7,6根火柴,要求n根火柴全部都用完且拼成的数字最大,输出这个数字。

一道很好的dp思维题。

然而我又聪明地把它看成了一道贪心，然后扣了半天都没扣出个东西来...

实际上还是比较容易推出dp方程的，很显然，dp需要记录的应该是所能形成的最大数字，那么用string就好了，然后加个判断函数。

发现 \(n \leqslant 10^4\) ，那么dp思路就出来了：\(f_i\) 表示用了 \(i\) 根火柴所能组成的最大数字，显然，最后加上的数字最多就只有9个，那么暴力递推一下就好了。

当然，需要注意的是，它要求刚好用完 \(n\) 根火柴，所以还需要考虑初始化，所以我把 \(f_i\) 一开始都设为了 “-”，\(f_0\) 为空。

const int N=10010;

struct Node{int v,c;}a[10];
int n,m,mp[]={0,2,5,5,4,5,6,3,7,6};
string f[N];

inline bool check(string A,string B){
	if(A=="-") return true;
	if(A.length()<B.length()) return true;
	else if(A.length()>B.length()) return false;
	else return A<B;
}

int main(){
	ios::sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	
	cin>>n>>m;
	for(int i=1,x;i<=m;++i){
		cin>>x;
		a[i]={x,mp[x]};
	}
	
	for(int i=1;i<=n;++i)
		f[i]="-";
	f[0]="";
	for(int i=1;i<=n;++i){
		for(int j=1;j<=m;++j)
			if(a[j].c<=i) if(f[i-a[j].c]!="-")
				if(check(f[i],f[i-a[j].c]+char(a[j].v+'0')))
					f[i]=f[i-a[j].c]+char(a[j].v+'0');
	}
//	for(int i=1;i<=n;++i)
//		cout<<i<<':'<<f[i]<<'\n';
	cout<<f[n]<<'\n';
	return 0;
}

---

NO.7 ABC276E

是道很有趣但是又有点恼人的题...

初看就很简单，但是感觉好像也不是很好判断...

然后想了半天，一直在bfs和dfs之间纠结，最后发现了一种比较好维护的bfs方法。

因为其实如果能形成回路，那么一定存在一个一进一出，所以可以考虑先把出发点四周的四个临近的点标上不同的号，然后进行bfs，如果发现有两个不同的标号有相交，则说明形成了回路。

const int N=1000010;

int n,m,sx,sy,dx[4]={0,1,0,-1},dy[4]={1,0,-1,0};
char a[N];

inline int trans(int x,int y)
{return (x<1||x>n||y<1||y>m)?1e9:m*(x-1)+y;}

struct Node{int x,y,type;};
queue<Node> q;
inline bool check(){
  for(int i=0;i<4;++i){
    int x=trans(sx+dx[i],sy+dy[i]);
    if(x>0&&x<=n*m&&a[x]!='#') q.push({sx+dx[i],sy+dy[i],i+1});
  } a[trans(sx,sy)]='#';

  while(!q.empty()){
    Node c=q.front(); q.pop();
    a[trans(c.x,c.y)]=c.type;
    for(int i=0;i<4;++i){
      int to=trans(c.x+dx[i],c.y+dy[i]);
      if(to<1||to>n*m) continue;
      if(a[to]!='#'&&a[to]!='.'&&a[to]!=c.type) return true;
      if(a[to]=='.'){
        q.push({c.x+dx[i],c.y+dy[i],c.type});
        a[to]=c.type;
      }
    }
  }
  return false;
}

int main(){
  ios::sync_with_stdio(false);
  cin.tie(NULL); cout.tie(NULL);
  
  cin>>n>>m;
  for(int i=1;i<=n;++i)
    for(int j=1;j<=m;++j){
      cin>>a[trans(i,j)];
      if(a[trans(i,j)]=='S')
        sx=i,sy=j;
    }
  if(check()) cout<<"Yes\n";
  else cout<<"No\n";
  return 0;
}

---

NO.8 ABC078D

感觉很牛马的证明题。

首先，如果只有一张牌，那么显然答案是 \(abs(a_n-y)\)

如果有两张牌，那么答案就是 \(max(abs(a_n-a_{n-1}),abs(a_n-y))\)

现在看大于两张牌的情况，

首先，显然先手可以取 \(n-1\) 或者 \(n\) 张牌，使得最后的答案和 \(n=2\) 时的一样，那么取完后剩余排数大于1张时呢？结论就是，根本没有必要，所以实际上 \(n>2\) 的情况和 \(n=2\) 的情况是一模一样的。

为什么捏？思考一下，如果你把主动权交给了后手，那么此时还剩下的两张或者更多的牌中，显然后手可以取到最后只剩下一张牌，那么也就是说最后的答案可以由后手决定为 \(a_n-a_{n-1}\) ，然而实际上第一轮选择时先手就已经可以达到这个答案了，所以如果你先手不取 \(n-1\) 或者 \(n\) 张牌，那么就相当于给了后手更多的减小答案的可能性，其中后手可以选择先手就能决定的答案，或者选择更小的答案。即不可能有比先手直接完或者剩下一张更优的答案了。

所以先手还不如一开始就决定好，因此，\(n\geqslant2\) 时，\(ans=max(abs(a_n-a_{n-1}),abs(a_n-y))\)

感觉其实这道题挺神奇的，它根本就没有讨论中间拿取的过程，而直接得出了最后的结论，因为中间的过程根本就没有必要。

const int N=2005;

int n,a[N],fx,fy;

int main(){
  ios::sync_with_stdio(false);
  cin.tie(NULL); cout.tie(NULL);

  cin>>n>>fx>>fy;
  for(int i=1;i<=n;++i)
    cin>>a[i];
  
  if(n==1||a[n]==a[n-1]) return cout<<abs(a[n]-fy)<<'\n',0;
  else cout<<max(abs(a[n]-a[n-1]),abs(a[n]-fy))<<'\n';

  return 0;
}

---

NO.9 ABC013C

这题满分 \(101\) 确实很有意思...

首先思考，先吃一定比后吃优，所以不妨直接考虑吃多少天正常餐和简单餐。

假如吃 \(x\) 天正常餐，\(y\) 天简单餐，那么应该满足 \(h+bx+dy-e(n-x-y)>0\)

显然是个一次函数，所以对于每个 \(x \in [0,n]\) 都求出最小 \(y\) 即可。

signed main(){
  //freopen();
  //freopen();
  IOS
  //int T;
  
  cin>>n>>h>>a>>b>>c>>d>>e;
  
  ll ans=llinf;
  for(ll x=0;x<=n;++x){
    ll A=(e+b),B=(e+d),C=(h-e*n);
    ll l=0,r=n-x;
    while(l<r){
      ll mid=(l+r)>>1;
      if(A*x+B*mid+C>0) r=mid;
      else l=mid+1;
    } ans=Min(ans,x*a+l*c);
    if(x*a+l*c==60) cout<<x<<' '<<l<<'\n';
  }
  cout<<ans<<'\n';
  return 0;
}

---

NO.10 ABC143E

真是道好题。

首先看到 \(n \leqslant 300\) 就先跑一遍 \(Floyd\) ，注意有些边要删。然后就需要思考了。

不难想到只有间距小于 \(L\) 的两点才能一步到达，所以再建个新图，其中边连着原图中间距小于 \(L\) 的两点，且边权为 \(1\) 。然后再跑个最短路 \(bfs\) 就好了。

const int N=305;

int n,m,cnt,head[N];
struct Edge{int to,nxt;}edge[N*N];
inline void Add(int fo,int to){
  edge[++cnt]={to,head[fo]};
  head[fo]=cnt;
} ll l,dis[N][N];

void bfs(int ori){
  queue<int> d;
  d.push(ori);
  dis[ori][ori]=0;
  while(d.size()){
    int pos=d.front(); d.pop();
    for(int i=head[pos];i;i=edge[i].nxt){
      int& to=edge[i].to;
      if(dis[ori][to]>dis[ori][pos]+1){
        dis[ori][to]=dis[ori][pos]+1;
        d.push(to);
      }
    }
  }
}

signed main(){
  //freopen();
  //freopen();
  IOS
  //int T;
  cin>>n>>m>>l;
  vector<pair<int,pair<int,ll>>> v;
  for(int i=1;i<=m;++i){
    int fo,to; ll val;
    cin>>fo>>to>>val;
    if(val>l) continue;
    v.push_back(make_pair(fo,make_pair(to,val)));
    v.push_back(make_pair(to,make_pair(fo,val)));
  }

  memset(dis,0x3f3f,sizeof(dis));
  for(int i=1;i<=n;++i) dis[i][i]=0;
  for(auto t:v) dis[t.first][t.second.first]=t.second.second;

  for(int i=1;i<=n;++i)
    for(int j=1;j<=n;++j)
      for(int k=1;k<=n;++k)
        dis[j][k]=Min(dis[j][k],dis[j][i]+dis[i][k]);
  
  for(int i=1;i<=n;++i)
    for(int j=1;j<=n;++j)
      if(i^j&&dis[i][j]<=l)
        Add(i,j);
  
  memset(dis,0x3f,sizeof(dis));
  for(int i=1;i<=n;++i) bfs(i);

  int q;
  cin>>q;
  while(q--){
    int s,t;
    cin>>s>>t;
    if(dis[s][t]>114514){
      cout<<-1<<'\n';
      continue;
    } else cout<<dis[s][t]-1<<'\n';
  }
  
  return 0;
}

23.8.4 EOF