Codeforces 908

最新推荐文章于 2024-07-25 23:26:35 发布

Xing_ke309

最新推荐文章于 2024-07-25 23:26:35 发布

阅读量136

点赞数 4

分类专栏： Cf DIv2 abc——step by step 文章标签：算法数据结构

本文链接：https://blog.csdn.net/Xing_ke/article/details/136238575

版权

Cf DIv2 abc——step by step 专栏收录该内容

12 篇文章 0 订阅

订阅专栏

文章讨论了一个关于整数数组的问题，给定一个数组，询问是否可以通过选择一个元素并左移数组来达到某个状态。关键在于判断是否存在环，如果存在环且步数有限，则无法确定是否可以回退到初始状态。

摘要由CSDN通过智能技术生成

C Anonymous Informant

题目大意

给定一个数组 $b$ ，问是否存在数组 $a$ ，进行 $k$ 次操作变为 $b$
操作为：选择数组 $a$ 中， $a_x=x$ 的一点，然后数组整体左移 $x$ 位
左移一位： $a_1,a_2,\cdots ,a_n\rightarrow a_2,\cdots a_n,a_1$
$1\leq k\leq 1e9,1\leq n\leq 2e5$

解题思路

对于 $a_i>n$ 的点，一定不会被选择
进行一次操作后， $a_x=x$ 的点会被移动到数组末尾
则对于 $b_n$ ，其一定是上一步进行操作所选的定点
考虑从数组 $b$ 反推回 $a$ ，若能回退 $k$ 步，则一定存在
由于回退过程中，若出现当前状态与前面某状态相同，则成环，之后可以回退任意步
对于末尾为 $x$ 的状态，下次再回到该状态，需要 $n/x$ 步
而最大环为末尾位一直为 $1$ ，大小为 $n$
所以若存在数组 $a$ ，最多回退 $n$ 步

package Tx;
import java.io.*;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.BitSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Random;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.Vector;







public class Tx1{
	static long md=(long)998244353;
	static long Linf=Long.MAX_VALUE/2;
	static int inf=Integer.MAX_VALUE/2;
	
	
	public static void main(String[] args) throws IOException{
		AReader input=new AReader();
	    PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
	    
	    int T=input.nextInt();
	    while(T>0){
	    	int n=input.nextInt();
	    	int k=input.nextInt();
	    	k=Math.min(n, k);
	    	int[] b=new int[n+1];
	    	for(int i=1;i<=n;++i) {
	    		b[i]=input.nextInt();
	    	}
	    	int last=n;
	    	boolean ok=true;
	    	for(int i=1;i<=k;++i) {
	    		if(b[last]>n) {
	    			ok=false;
	    			break;
	    		}
	    		last-=b[last];
	    		if(last<=0)last+=n;
	    	}
	    	if(ok)out.println("Yes");
	    	else out.println("No");
	    	T--;
	    }
 	    out.flush();
	    out.close();
	}
	//System.out.println();
	//out.println();
	static
	class AReader{
	    BufferedReader bf;
	    StringTokenizer st;
	    BufferedWriter bw;

	    public AReader(){
	        bf=new BufferedReader(new InputStreamReader(System.in));
	        st=new StringTokenizer("");
	        bw=new BufferedWriter(new OutputStreamWriter(System.out));
	    }
	    public String nextLine() throws IOException{
	        return bf.readLine();
	    }
	    public String next() throws IOException{
	        while(!st.hasMoreTokens()){
	            st=new StringTokenizer(bf.readLine());
	        }
	        return st.nextToken();
	    }
	    public char nextChar() throws IOException{
	        //确定下一个token只有一个字符的时候再用
	        return next().charAt(0);
	    }
	    public int nextInt() throws IOException{
	        return Integer.parseInt(next());
	    }
	    public long nextLong() throws IOException{
	        return Long.parseLong(next());
	    }
	    public double nextDouble() throws IOException{
	        return Double.parseDouble(next());
	    }
	    public float nextFloat() throws IOException{
	        return Float.parseFloat(next());
	    }
	    public byte nextByte() throws IOException{
	        return Byte.parseByte(next());
	    }
	    public short nextShort() throws IOException{
	        return Short.parseShort(next());
	    }
	    public BigInteger nextBigInteger() throws IOException{
	        return new BigInteger(next());
	    }
	    public void println() throws IOException {
	        bw.newLine();
	    }
	    public void println(int[] arr) throws IOException{
	        for (int value : arr) {
	            bw.write(value + " ");
	        }
	        println();
	    }
	    public void println(int l, int r, int[] arr) throws IOException{
	        for (int i = l; i <= r; i ++) {
	            bw.write(arr[i] + " ");
	        }
	        println();
	    }
	    public void println(int a) throws IOException{
	        bw.write(String.valueOf(a));
	        bw.newLine();
	    }
	    public void print(int a) throws IOException{
	        bw.write(String.valueOf(a));
	    }
	    public void println(String a) throws IOException{
	        bw.write(a);
	        bw.newLine();
	    }
	    public void print(String a) throws IOException{
	        bw.write(a);
	    }
	    public void println(long a) throws IOException{
	        bw.write(String.valueOf(a));
	        bw.newLine();
	    }
	    public void print(long a) throws IOException{
	        bw.write(String.valueOf(a));
	    }
	    public void println(double a) throws IOException{
	        bw.write(String.valueOf(a));
	        bw.newLine();
	    }
	    public void print(double a) throws IOException{
	        bw.write(String.valueOf(a));
	    }
	    public void print(char a) throws IOException{
	        bw.write(String.valueOf(a));
	    }
	    public void println(char a) throws IOException{
	        bw.write(String.valueOf(a));
	        bw.newLine();
	    }
	}
}