HDU异或密码

最新推荐文章于 2022-03-22 17:29:51 发布

贫嘴小李子的幸福生活

最新推荐文章于 2022-03-22 17:29:51 发布

阅读量605

点赞数

CC 4.0 BY-SA版权

分类专栏： Java足迹

本文链接：https://blog.youkuaiyun.com/u013491262/article/details/53046426

Java足迹专栏收录该内容

272 篇文章

订阅专栏

本文介绍了一种基于异或运算的密码挑战，通过寻找序列中连续子序列的异或结果来解决特定问题。提供了完整的Java实现代码，包括输入处理、算法实现及输出结果。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

异或密码

Problem Description

晨晨在纸上写了一个长度为N的非负整数序列{

ai}。对于这个序列的一个连续子序列{

al,al+1,…，ar}晨晨可以求出其中所有数异或的结果

alxoral+1xor...xorar其中xor表示位异或运算，对应C、C++、 Java等语言中的^运算。
小璐提出了M个询问，每个询问用一个整数

xi描述。
对于每个询问，晨晨需要找到序列{

ai}的所有连续子序列，求出每个子序列异或的结果，找到所有的结果中与

xi之差的绝对值最小的一个，并告诉小璐相应子序列的长度。
若有多个满足条件的连续子序列，则告诉小璐这些子序列中最长的长度。

Input

包含多组测试数据，第一行一个正整数T，表示数据组数。
每组数据共两行。
第一行包含N+1个非负整数。其中第一个数为N，表示序列的长度；接下来N 个数，依次描述序列{

ai}中的每个数。
第二行包含M+1个整数。其中第一个数为M，表示询问的个数；接下来M个数

xi，每个数对应题目描述中的一个询问。
保证 1 <= N <= 100，1 <= M <= 100，

ai <= 1024，|

xi| <= 1024，数据组数 <= 100。

Output

对于每组数据输出M + 1行。前M行对应晨晨M个询问的回答，第M + 1行为空行

Sample Input

Sample Output

模拟

import java.io.BufferedInputStream;
import java.io.BufferedReader;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.PrintWriter;
import java.math.BigInteger;
import java.util.Arrays;
import java.util.Scanner;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args) {
        new Task().solve(); ; 
    }
}

class  Task{  
    Scanner in = new Scanner(new BufferedInputStream(System.in)) ;
    PrintWriter out = new PrintWriter(System.out) ;
    
    int[] a = new int[108] ;
    int[] sum = new int[108] ;
    int[] len = new int[1028] ;
    int[] anslen = new int[1028] ;
    int[] ansid = new int[1028] ;
    int idx ; 
    
    void solve(){ 
        int t = in.nextInt() ;
        for(int ca = 1 ; ca <= t ; ca++){
            int n = in.nextInt() ;
            for(int i = 1 ; i <= n ; i++) a[i] = in.nextInt() ;
            sum[1] = a[1] ;
            for(int i = 2 ; i <= n ; i++) sum[i] = a[i] ^ sum[i-1] ;
            
            Arrays.fill(len , -1) ;
            int big1024 = -1 ;
            idx = 0 ;
            for(int i = 1 ; i <= n ; i++){
                for(int j = i ; j <= n ; j++){
                    int nowsum = j == 1 ? sum[j] : sum[j] ^ sum[i-1] ;
                    int nowlen = j-i+1  ;
                    if(nowsum <= 1024) 
                        len[nowsum] = Math.max(len[nowsum], nowlen) ;
                    else{
                        if(big1024 == -1 || big1024 > nowsum){
                            big1024 = nowsum ;
                            len[1025] = nowlen ;
                        }
                        else if(big1024 == nowsum) len[1025] = Math.max(len[1025] , nowlen) ;
                    }
                }
            }
            int res = -1 , faid = -1 ;
            Arrays.fill(ansid , -1) ;
            for(int i = 0 ; i <= 1024 ; i++){
                if(len[i] != -1){
                    faid = i ;
                    res = len[i] ;
                }
                ansid[i] = faid ;
                anslen[i] = res ;
            }
            res = len[1025] ;
            faid = big1024 ;
            for(int i = 1024 ; i >= 0 ; i--){
                if(len[i] != -1){
                    res = len[i] ;
                    faid = i ;
                }
                if(faid == -1) continue  ;
                if(ansid[i] == -1){
                    anslen[i] = res ;
                    continue ;
                }
                
                
                if(i - ansid[i] == faid - i){
                    anslen[i] = Math.max(anslen[i] , res) ;
                }
                else if(i - ansid[i] > faid - i){
                    anslen[i] = res ; 
                }
                
            }
            
            
            int m = in.nextInt() ;
            while(m-- > 0){
                int q = in.nextInt() ;
                if(q < 0) q = 0 ;
                out.println(anslen[q]) ;
            }
            out.println() ;
        }
        out.flush() ; 
    }
    
} 

class InputReader {  
    public BufferedReader reader;  
    public StringTokenizer tokenizer;  
  
    public InputReader(InputStream stream) {  
        reader = new BufferedReader(new InputStreamReader(stream), 32768);  
        tokenizer = new StringTokenizer("");  
    }  
  
    private void eat(String s) {  
        tokenizer = new StringTokenizer(s);  
    }  
  
    public String nextLine() {  
        try {  
            return reader.readLine();  
        } catch (Exception e) {  
            return null;  
        }  
    }  
  
    public boolean hasNext() {  
        while (!tokenizer.hasMoreTokens()) {  
            String s = nextLine();  
            if (s == null)  
                return false;  
            eat(s);  
        }  
        return true;  
    }  
  
    public String next() {  
        hasNext();  
        return tokenizer.nextToken();  
    }  
  
    public int nextInt() {  
        return Integer.parseInt(next());  
    }  
  
    public long nextLong() {  
        return Long.parseLong(next());  
    }  
  
    public double nextDouble() {  
        return Double.parseDouble(next());  
    }  
  
    public BigInteger nextBigInteger() {  
        return new BigInteger(next());  
    }  
  
}