精华内容
下载资源
问答
  • 题意:给定\(a[l...r]\),次询问区间\([l,r]\)中的最大连续异或和\(a_i⊕a_{i+1}⊕...⊕a_{j},l≤i≤j≤r\) 一眼过去认为是不可做的,但题目给出\(n=1.2e4\),提供了分块暴力的余地 首先处理成前缀形式,对于询问\([l,r...

    题意:给定\(a[l...r]\),多次询问区间\([l,r]\)中的最大连续异或和\(a_i⊕a_{i+1}⊕...⊕a_{j},l≤i≤j≤r\)

    一眼过去认为是不可做的,但题目给出\(n=1.2e4\),提供了分块暴力的余地

    首先处理成前缀形式,对于询问\([l,r]\)既为\([l-1,r]\)中寻找两个数xor最大

    维护\(f[i][j]\):第i个块到第j个数的任意异或最大值

    这个只需\(O(30*n\sqrt{n})\)的代价即可预处理

    对于每次询问,首个残缺的块暴力,其余块直接由\(f\)得到答案,复杂度\(O(30*m\sqrt{n})\)

    Yet Another Similar Problem : https://www.cnblogs.com/caturra/p/8429665.html

    #include<bits/stdc++.h>
    #define rep(i,j,k) for(register int i=j;i<=k;i++)
    #define rrep(i,j,k) for(register int i=j;i>=k;i--)
    #define erep(i,u) for(register int i=head[u];~i;i=nxt[i])
    #define iter(i,j) for(int i=0;i<(j).size();i++)
    #define print(a) printf("%lld",(ll)a)
    #define println(a) printf("%lld\n",(ll)a)
    #define printbk(a) printf("%lld ",(ll)a)
    #define IOS ios::sync_with_stdio(0)
    using namespace std;
    const int MAXN = 2e4+11;
    const int oo = 0x3f3f3f3f;
    typedef long long ll;
    ll read(){
        ll x=0,f=1;register char ch=getchar();
        while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
        while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
        return x*f;
    }
    int T[MAXN],a[MAXN],b[MAXN];
    struct TRIE{
        int tot;
        int son[MAXN*40][2],size[MAXN*40];
        void init(){
            tot=0;
            son[0][0]=son[0][1]=size[0]=0;
            memset(T,0,sizeof T);
        }
        int insert(int old,int val){
            int rt,o;rt=o=++tot;
            rrep(i,30,0){
                son[o][0]=son[old][0],
                son[o][1]=son[old][1];
                size[o]=size[old]+1;
                int wh=val>>i&1;
                son[o][wh]=++tot;
                old=son[old][wh];
                o=son[o][wh];
            }
            size[o]=size[old]+1;
            return rt;
        }
        int query(int l,int r,int val){
            int ans=0;
            rrep(i,30,0){
                int wh=val>>i&1;
                if(size[son[r][wh^1]]-size[son[l][wh^1]]){
                    ans|=(1<<i),r=son[r][wh^1],l=son[l][wh^1];
                }else{
                    r=son[r][wh],
                    l=son[l][wh];
                }
            }
            return ans;
        }
    }trie;
    vector<int> vec[233];
    int head[233],pos[MAXN];
    int f[233][MAXN];
    int main(){
        int n,m;
        while(cin>>n>>m){
            trie.init();
            rep(i,1,n) a[i]=read();
            rep(i,1,n) b[i]=b[i-1]^a[i];
            rep(i,1,n) T[i]=trie.insert(T[i-1],b[i]);
            int sz=sqrt(n)+1;
            rep(i,1,sz+3) vec[i].clear();
            int now=0; 
            rep(i,1,n){
                if(vec[now].size()==sz||now==0) head[++now]=i;
                vec[now].push_back(a[i]);
                pos[i]=now;
            }
            memset(f,0,sizeof f);
            rep(i,1,now){
                rep(j,head[i],n){
                    f[i][j]=max(f[i][j-1],trie.query(T[head[i]-1],T[j],b[j]));
                }
            }
            int ans=0;
            while(m--){
                int l=read();
                int r=read();
                int x=((ll)l+ans)%n+1;
                int y=((ll)r+ans)%n+1;
                l=min(x,y); r=max(x,y);
                ans=0;
                --l;
                if(pos[l]==pos[r]){
                    rep(i,l,r){
                        ans=max(ans,trie.query(T[l-1],T[r],b[i]));
                    }
                }else{
                    ans=f[pos[l]+1][r];//best[pos[l+1]][r]
                    rep(i,l,head[pos[l]+1]-1){
                        ans=max(ans,trie.query(T[l-1],T[r],b[i]));
                    }
                }
                println(ans);
            }
        }
        return 0;
    }

    转载于:https://www.cnblogs.com/caturra/p/9465866.html

    展开全文
  • // 有1到N共 n-1个数,问少了哪个数 // 有序数组(如果是无序数组那么将a[i] 移动至 a[a[i...这个时候可以不确认一下N是多少,然后,连续的每4个数异或出来的结果为0,这样即省去了数组的开销 public static void ...

    // 有1到N共 n-1个数,问少了哪个数
    // 有序数组(如果是无序数组那么将a[i] 移动至 a[a[i]] 这样子就成功排序了)

    //其实可以采用byte数组的来做,感觉会更快

    //当然,这个更多的是用在1-n 共n+1个数,问多出来的那个数是多少?这个时候可以不确认一下N是多少,然后,连续的每4个数异或出来的结果为0,这样即省去了数组的开销

    public static void lessOne(int[] a) {
      int fruit = 0;
      int count = 0;
      for (int i = 0; i < a.length; i++) {
      count++;
      fruit ^= a[i];
      if (count == 4) {
        if (fruit == 0) {
          count = 0;
        } else {
    
        System.out.println("Less is:" + i);
        break;
        }
        }
      }
    }

     

    下面为测试代码

    int[] a = new int[100];
    for (int i = 0; i < a.length; i++) {
      if (i == 67)
        continue;
      a[i] = i;
    }
    //也可以使用已提供的方法进行排序,但不建议
    //Arrays.sort(a);
    lessOne(a);

     

     

    // 有一组数,中间有两个数的出现次数为奇数次,问是哪两个数

    public static void lesstwoj() {
    int[] a = { 1, 1, 2, 2, 3, 3, 4, 5, 5, 6, 6, 7, 7, 8 };
      int sum = 0;
      for (int i : a) {
        sum ^= i;
      }
      int count = 0;
      int temp = sum;
      while ((temp & 1) == 0) {
      temp >>= 1;
      count++;
      }
      int one = 0;
      for (int i : a) {
        if (((i >> count) & 1) != 0) {
          one ^= i;
        }
      }
      int sec = sum ^ one;
      System.out.println("one:" + one);//第一个数
      System.out.println("sec:" + sec);//第二个数
    }

     

     

    // 采用异或运算来进行交换位置

    //不借助于第三个数

    public static void swap(int a, int b) {
      if (a != b) {
        a = a ^ b;
        b = a ^ b;
        a = a ^ b;
      }
      System.out.println("one-- a:" + a + " b:" + b);
    }

     

    转载于:https://www.cnblogs.com/ahhy/p/4383668.html

    展开全文
  • 在取奇/偶数个数使得异或和最大,给所有权值加上一个2N2^N2N后加入线性基,如果需要取奇数个数就带入0,取偶数个数就带入2N2^N2N到线性基中查询最大异或和就可以了。 T2:树 一段连续的编号不好用数据结构维护距离...
    T1:签到

    因为题解说的实在太好了所以就直接粘贴了。
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在这里插入图片描述
    在取奇/偶数个数使得异或和最大,给所有权值加上一个2N2^N后加入线性基,如果需要取奇数个数就带入0,取偶数个数就带入2N2^N到线性基中查询最大异或和就可以了。

    T2:树

    在这里插入图片描述
    一段连续的编号不好用数据结构维护距离,但是用一次dfs/bfs可以很方便地求出每个点到一段连续编号的最近距离。
    在这里插入图片描述
    在这里插入图片描述
    O((n+m)log2)O((n+m)log^2)的做法还有点分治,每个点分中心开一棵动态开点线段树(卡空间的话用指针开siz大小的线段树然后build),查询就在点分树上跳父亲在对应的线段树中查询区间最小值。
    离线的话更好写,直接把询问挂到每个点上,建出一个点分中心的线段树后直接遍历子树中的询问然后查询对应的区间最小值(甚至可以用ST表),每一层的线段树查询完之后就没用了所以可以共用一个空间,空间就是O(nlogn)O(nlogn)的。

    Code:

    #include<bits/stdc++.h>
    #define maxn 100005
    using namespace std;
    char cb[1<<20],*cs,*ct;
    #define getc() (cs==ct&&(ct=(cs=cb)+fread(cb,1,1<<20,stdin),cs==ct)?0:*cs++)
    inline void read(int &a){
    	char c;while(!isdigit(c=getc()));
    	for(a=c-'0';isdigit(c=getc());a=a*10+c-'0');
    }
    int n,m,siz[maxn],S[maxn],top,dis[maxn],st[maxn][18],lg[maxn],ans[maxn];
    bool vis[maxn];
    int fir[maxn],nxt[maxn<<1],to[maxn<<1],w[maxn<<1],tot;
    inline void line(int x,int y,int z){nxt[++tot]=fir[x],fir[x]=tot,to[tot]=y,w[tot]=z;}
    struct node{int id,l,r;};
    vector<node>Q[maxn];
    void getroot(int u,int ff,int tsz,int &g){
    	siz[u]=1; bool flg=1;
    	for(int i=fir[u],v;i;i=nxt[i]) if(!vis[v=to[i]]&&v!=ff)
    		getroot(v,u,tsz,g),siz[u]+=siz[v],flg&=siz[v]<<1<=tsz;
    	if(flg&&(tsz-siz[u])<<1<=tsz) g=u;
    }
    void dfs(int u,int ff){
    	S[++top]=u;
    	for(int i=fir[u],v;i;i=nxt[i]) if(!vis[v=to[i]]&&v!=ff) dis[v]=dis[u]+w[i],dfs(v,u);
    }
    inline int RMQ(int x,int y){
    	int k=lg[y-x+1];
    	return min(st[x][k],st[y-(1<<k)+1][k]);
    }
    void solve(int u){
    	dis[u]=top=0,dfs(u,0),sort(S+1,S+1+top),lg[0]=-1;
    	for(int i=1;i<=top;i++) lg[i]=lg[i>>1]+1,st[i][0]=dis[S[i]];
    	for(int j=1;j<=lg[top];j++)
    		for(int i=1,l=1<<j;i+l-1<=top;i++)
    			st[i][j]=min(st[i][j-1],st[i+(l>>1)][j-1]);
    	for(int i=1,l,r;i<=top;i++)
    		for(int j=0,x=S[i],lim=Q[x].size();j<lim;j++)
    			if((l=lower_bound(S+1,S+1+top,Q[x][j].l)-S)<=(r=upper_bound(S+1,S+1+top,Q[x][j].r)-S-1))
    				ans[Q[x][j].id]=min(ans[Q[x][j].id],dis[x]+RMQ(l,r));
    }
    void TDC(int u,int tsz){
    	getroot(u,0,tsz,u),vis[u]=1,solve(u);
    	for(int i=fir[u],v;i;i=nxt[i]) if(!vis[v=to[i]]) TDC(v,siz[v]<siz[u]?siz[v]:tsz-siz[u]);
    }
    int main()
    {
    	freopen("tree.in","r",stdin);
    	freopen("tree.out","w",stdout);
    	read(n); int l,r,x,y,z;
    	for(int i=1;i<n;i++) read(x),read(y),read(z),line(x,y,z),line(y,x,z);
    	read(m);
    	for(int i=1;i<=m;i++) read(l),read(r),read(x),ans[i]=x<l||x>r?Q[x].push_back((node){i,l,r}),1e9:0;
    	TDC(1,n);
    	for(int i=1;i<=m;i++) printf("%d\n",ans[i]);
    }
    

    线段树分治+虚树做法(by Freopen):

    #include<bits/stdc++.h>
    #define maxn 100005
    #define lim 18
    using namespace std;
    
    int n,m,ans[maxn],lg[maxn<<1];
    int info[maxn],Prev[maxn<<1],to[maxn<<1],cst[maxn<<1],cnt_e;
    void Node(int u,int v,int c){ Prev[++cnt_e]=info[u],info[u]=cnt_e,to[cnt_e]=v,cst[cnt_e]=c; }
    int fir[maxn],nxt[maxn<<1],tar[maxn<<1],cnte;
    void add(int u,int v){ nxt[++cnte] = fir[u] , fir[u] = cnte , tar[cnte] = v; }
    
    vector<pair<int,int> >G[maxn<<2];
    int dep[maxn],st[lim][maxn<<1],St[maxn],Ed[maxn],tot;
    
    void dfs(int u,int ff){
    	st[0][St[u] = ++tot] = u;
    	for(int i=info[u],v;i;i=Prev[i]) if((v=to[i])^ff){
    		dep[v] = dep[u] + cst[i];
    		dfs(v,u);
    		st[0][++tot] = u;
    	}
    	Ed[u] = tot;
    }
    
    int Lca(int u,int v){
    	u = St[u] , v = St[v];
    	if(u > v) swap(u,v);
    	int t = lg[v - u + 1];
    	return dep[st[t][u]] < dep[st[t][v-(1<<t)+1]] ? st[t][u] : st[t][v-(1<<t)+1];
    }
    
    #define lc u<<1
    #define rc u<<1|1
    void ins(int u,int l,int r,int ql,int qr,pair<int,int> x){
    	if(ql > r || l > qr) return;
    	if(ql <= l && r <= qr) return (void)(G[u].push_back(x));
    	int m = l+r>>1;
    	ins(lc,l,m,ql,qr,x),ins(rc,m+1,r,ql,qr,x);
    }
    
    bool cmp(const int &u,const int &v){
    	return St[u] < St[v];
    }
    
    int f[maxn];
    void dfs1(int u,int ff,int l,int r){
    	f[u] = (l <= u && u <= r) ? 0 : 0x3f3f3f3f;
    	for(int i=fir[u],v;i;i=nxt[i]) if((v=tar[i])^ff){
    		dfs1(v,u,l,r);
    		f[u] = min(f[u] , f[v] - dep[u] + dep[v]);
    	}
    }
    
    void dfs2(int u,int ff){
    	for(int i=fir[u],v;i;i=nxt[i]) if((v=tar[i])^ff){
    		f[v] = min(f[v] , f[u] + dep[v] - dep[u]);
    		dfs2(v,u);
    	}
    }
    
    void Solve(int u,int l,int r){
    	if(l > r) return;
    	int m = l+r >> 1;
    	if(l != r)	Solve(lc,l,m),Solve(rc,m+1,r);
    	static int ar[maxn<<1]={},cnt=0,q[maxn]={},R,pts[maxn]={},ptc=0;
    	cnt = R = cnte = ptc = 0;
    	for(int i=l;i<=r;i++) ar[cnt++] = i;
    	for(int i=0;i<G[u].size();i++) ar[cnt++] = G[u][i].first;
    	sort(ar,ar+cnt,cmp);
    	cnt = unique(ar,ar+cnt) - ar;
    	for(int i=0;i<cnt;i++){
    		if(R){
    			int t=Lca(ar[i] , q[R]) , p = 0;
    			for(;R && dep[q[R]] > dep[t];p = q[R--]) if(p)
    				add(q[R] , p);
    			if(q[R] ^ t) q[++R] = pts[++ptc] = t;
    			if(p) add(q[R] , p);
    		}
    		q[++R] = pts[++ptc] = ar[i];
    	}
    	for(int p=0;R;p=q[R--]) if(p)
    		add(q[R] , p);
    	dfs1(q[1],0,l,r),dfs2(q[1],0);
    	for(int i=0;i<G[u].size();i++)
    		 ans[G[u][i].second] = min(ans[G[u][i].second] , f[G[u][i].first]);
    	for(;ptc;) fir[pts[ptc--]] = 0;
    }
    
    int main(){
    	
    	freopen("tree.in","r",stdin);
    	freopen("tree.out","w",stdout);
    	
    	scanf("%d",&n);
    	for(int i=1;i<n;i++){
    		int u,v,l;scanf("%d%d%d",&u,&v,&l);
    		Node(u,v,l),Node(v,u,l);
    	}
    	dfs(1,0);
    	for(int i=2;i<=tot;i++) lg[i] = lg[i>>1] + 1;
    	for(int j=1;j<lim;j++) for(int i=1;i<=tot-(1<<j)+1;i++)
    		st[j][i] = dep[st[j-1][i]] < dep[st[j-1][i + (1<<j-1)]] ? st[j-1][i] : st[j-1][i + (1<<j-1)];
    	scanf("%d",&m);
    	for(int i=1;i<=m;i++){
    		int l,r,x;
    		scanf("%d%d%d",&l,&r,&x);
    		ins(1,1,n,l,r,make_pair(x,i));	
    		ans[i] = 0x3f3f3f3f;
    	}
    	Solve(1,1,n);
    	
    	for(int i=1;i<=m;i++) 
    		printf("%d\n",ans[i]);
    }
    
    
    T3:区间

    在这里插入图片描述
    不同的权值个数没什么好办法,强制在线多个区间,只有用bitset强上。
    肯定是要分块的,但分块之后直接合并复杂度就是O(n2n/w)O(n^2\sqrt n/w)了,显然无法承受。
    还要优化中间整块的合并过程,我们有线段树和ST表两种方式,但是线段树的合并仍然是O(n2/wlog)O(n^2/w*log)的,所以选择ST表。
    建立的复杂度是O((nSlognS)nw)O((\frac nS\log\frac nS)*\frac nw),合并是O(n2w)O(\frac {n^2}w),散块暴力是O(nS)O(nS)
    空间复杂度和建立的复杂度相同,而空间限制只有8MB8\text{MB},所以SS要开大些,1700左右,甚至更大。
    然后卡常,手写bitset会快于STL,实测1.8s1s1.8s\rarr1s
    然鹅出题人还有奇思妙想。。
    在这里插入图片描述
    Code(最后那个优化我没加,勉强卡过):

    #include<bits/stdc++.h>
    #define maxn 100005
    using namespace std;
    inline void read(int &a){
    	char c;while(!isdigit(c=getchar()));
    	for(a=c-'0';isdigit(c=getchar());a=a*10+c-'0');
    }
    const int S = 1700, all = (1<<16)-1;
    int n,m,T,N,ans,a[maxn],b[maxn],lg[62]={-1},dt[1<<16],tot;
    struct bitset{
    	unsigned int a[(maxn>>5)+3];
    	bitset operator | (const bitset &b)const{bitset c; for(int i=0;i<=tot;i++) c.a[i]=a[i]|b.a[i]; return c;}
    	void reset(){memset(a,0,(tot+1)<<2);}
    	void set(int x){a[x>>5]|=1u<<(x&31);}
    	int count(){int s=0;for(int i=0;i<=tot;i++) s+=dt[a[i]>>16]+dt[a[i]&all];return s;}
    }st[6][58],now;
    int main()
    {
    	freopen("interval.in","r",stdin);
    	freopen("interval.out","w",stdout);
    	for(int i=1;i<=all;i++) for(int x=i;x;x&=(x-1)) ++dt[i];
    	read(n),read(m),read(T),N=(n-1)/S;//remove the last block.
    	for(int i=1;i<=n;i++) read(a[i]),b[i]=a[i];
    	sort(b+1,b+1+n),tot=unique(b+1,b+1+n)-b-1;
    	for(int i=1;i<=n;i++) a[i]=lower_bound(b+1,b+1+tot,a[i])-b-1; tot=(tot-1)>>5;
    	for(int i=1;i<=N;i++) lg[i]=lg[i>>1]+1;
    	for(int i=0;i<N;i++)
    		for(int j=i*S+1,r=i*S+S;j<=r;j++)
    			st[0][i].set(a[j]);
    	for(int j=1;j<=lg[N];j++)
    		for(int i=0,l=1<<j;i+l<=N;i++)
    			st[j][i]=st[j-1][i]|st[j-1][i+(l>>1)];
    	for(int Q=1,l,r,x,y,t,k;Q<=m;Q++){
    		read(k),now.reset();
    		while(k--){
    			read(l),read(r);
    			if(T&&Q>1) {l=(l^ans)%n+1,r=(r^ans)%n+1; if(l>r) swap(l,r);}
    			x=(l-1)/S,y=(r-1)/S;
    			if(y-x<=1) {for(int i=l;i<=r;i++) now.set(a[i]);continue;}
    			for(int i=l,lim=x*S+S;i<=lim;i++) now.set(a[i]);
    			for(int i=r,lim=y*S+1;i>=lim;i--) now.set(a[i]);
    			t=lg[y-x-1];
    			now=now|st[t][x+1]|st[t][y-(1<<t)];
    		}
    		printf("%d\n",ans=now.count());
    	}
    }
    
    展开全文
  • 奶牛异或

    2017-03-06 19:35:42
    题目描述 农民约翰在喂奶牛的时候被另一个问题卡住了。他的所有N(1 ,000)个奶牛在...帮助农民约翰找出应该从那一头奶牛开始喂,使得从它开始的某一个连续的自序列上的奶牛的异或最大。如果有多个这样的子序列,选

    题目描述
    农民约翰在喂奶牛的时候被另一个问题卡住了。他的所有N(1 <= N <= 100,000)个奶牛在他面前排成一行(按序号1..N的顺序),按照它们的社会等级排序。奶牛#1由最高的社会等级,奶牛#N最低。每个奶牛同时被赋予了一个唯一的数在0..2^21 - 1的范围内。帮助农民约翰找出应该从那一头奶牛开始喂,使得从它开始的某一个连续的自序列上的奶牛的数的异或最大。如果有多个这样的子序列,选择结尾的奶牛社会等级最高的。如果还不唯一,选择最短的。

    输入
    • 第1行:一个单独的整数N。 • 第2到N + 1行:N个0..2^21 – 1之间的整数,代表每头奶牛的被赋予的数。第j行描述了社会等级j – 1的奶牛。

    输出
    • 第 1 行: 3个空格隔开的整数,分别为:最大的异或值,序列的起始位置、终止位置。

    样例输入
    5
    1
    0
    5
    4
    2
    样例输出
    6 4 5

    Solution

    trie树的应用

    #include<cstdio>
    #include<cstring>
    #include<iostream>
    using namespace std;
    int n,v,tot,ans,cow;
    int a[100005],s[100005],b[40];
    struct ty
    {
        int Next[2];
        void init()
        {
            memset(Next,-1,sizeof(Next));
        }
    }p[3000005];
    void work(int x)
    {
        int k=0;
        while(x>0) 
        {
            k++;
            b[k]=x%2;
            x=x/2;
        }
        for(int i=k+1;i<=31;i++) b[i]=0;
    }
    void Insert()
    {
        int now,k;
        now=0;
        for(int i=31;i>=1;i--) 
        {
            k=b[i];
            if(p[now].Next[k]==-1) 
            {
                tot++;
                p[tot].init();
                p[now].Next[k]=tot;
            }
            now=p[now].Next[k];
        }
    }
    void query(int id)
    {
        int now,k,val;
        now=0;val=0;
        for(int i=31;i>=1;i--) 
        {
            k=b[i];
            if(p[now].Next[k^1]!=-1) 
            {
                val+=(1<<(i-1));
                now=p[now].Next[k^1];
            }
            else now=p[now].Next[k];
        }
        if(val>ans) 
        {
            ans=val;
            cow=id;
        }
        if(val==ans) 
        {
            if(id<cow) cow=id;
        }
    }
    int main()
    {
        cin>>n;
        for(int i=1;i<=n;i++) 
        {
            scanf("%d",&a[i]);
            s[i]=s[i-1]^a[i];
        }
        ans=-1e9;
        p[0].init();
        work(0);
        Insert();
        for(int i=1;i<=n;i++) 
        {
            work(s[i]);
            Insert();
            query(i);
        }
        for(int i=cow;i>=1;i--) 
        {
            v=v^a[i];
            if(v==ans) 
            {
                cout<<ans<<' '<<i<<' '<<cow;
                return 0;
            }
        }
        return 0;
    }
    展开全文
  •  最近Leetcode官方连续推荐了3天的异或题目,不把我异或教会不罢休啊,不说了直接上代码,详细看 Leetcode官方题解吧。  异或运算满足结合律和交换律,且任意数异或自身等于 0。  上式可化简为整体思路还是秉持...
  • 字典树处理《异或

    2016-08-11 16:51:54
    题目: 问题很简单,现在有一个数组a1,a2,...第一行有一个整数n(1^5),表示数组的元素个数。第二行有n个元素,依次表示数组的元素。(0^6) Output 每组输出一行,这行仅一个数字。表示最大的连续子段异或值。 Samp
  • 题意是在一数列中找到一段连续的子串使其异或值与所给值最接近,求出子串长度,若有组结果,输出最大长度。 做题之前一定注意数据范围,这道题就可以直接暴力,用数组 p[ i ][ j ] 表示长度为 i 的的第 j+1...
  • 思路:如果没有异或的操作,就是直接简单的区间合并记录每个区间的从左开始的1的连续个数和从右开始的1的连续个数即可,而异或操作,可以在记录一个从左从右开始的0的个数就可以了,异或时直接交换这两个值即可#...
  • 给定一个数kkk,次询问[l,r][l,r][l,r]之间有多少个连续的子串使得它们的异或和为kkk。 思路: 由于异或具有交换性和自反性,所以我们可以用这样的性质我们就用莫队暴力搞。 代码: // luogu-judger-...
  • 看了题解还是不太懂 , 简单...题解: 1 ~ 2^n-1个数之间 , 任意多个连续组成都有可能是答案,所以首先求a[i]的前缀和。 al⊕al+1⋯⊕ar=bl−1⊕br。 若b[i]前缀和里面有相等的俩个数 , 那么必有某个连续区间异...
  • Time Limit: 2000 MS Memory Limit: 65536 KBDescription问题很简单,现在有一个数组a1,a2,a3……an。...第一行有一个整数n(1^5),表示数组的元素个数。第二行有n个元素,依次表示数组的元素。(0^6)Ou
  • 即使有多个不同答案,你也只需要返回其中一种。 格雷编码序列必须以 0 开头。 示例 1: 输入: 2 输出: [0,1,3,2] 解释: 00 - 0 01 - 1 11 - 3 10 - 2 对于给定的 n,其格雷编码序列并不唯一。 例如,[0,2,3,1] 也是...
  • 原文链接:http://blog.csdn.net/SO_zxn/article/details/79166249 近期看到了java异或的特征:一个数连续两次异或一个数,则不改变原大小,所以想到了用这个原则可以实现不利用第三变量实现对两个数值的交换。...
  • 要求把序列分为多个连续的段,保证分完之后, 无论选取那些段相异或答案都不是0,问最多可以分为多少段。 1&amp;lt;=n&amp;lt;=2∗1051&amp;lt;=n&amp;lt;=2*10^51&lt;=n&lt;=2∗105 0&...
  • 对于一个表示子集位串的子组x:例如:X=xxx0 1111 0000 ...3.因为位元个数要求相同,r与X异或的到结果数中1的个数比X中小x后面的1的个数1个。 4.将X与r的异或结果右靠齐,并右移两位得到R。 5.R和r与得到最后结果。
  • 给你一个长度为n的排列,每次询问由l,r构成,你需要回答区间[l,r]形成的连续连续段由是由多个相邻的构成。 例如1,2,3,4为一个连续段,1,3是两个连续段. 对于一个长度为5的排列为:1,3,5,2,4。询问区间为[2...
  • ‘’’ 找出唯一一只出现过一次...“出现次”:只有出现偶数次,才可以用异或 ‘’’ data = input() data += ',' num = 0 h = 0 for i in range(len(data)): if data[i] != ',': num = num * 10 + int(data[i]
  • 然后取任意多个连续的数,让他们 异或操作。 计算有多少种取法,使操作后结果为0. 做法:连续就想到了前缀和。 把前i个a的异或操作结果放在 num[i]中, 那么a【i】到a【j】个数异或结果就是 num[j]^num[i-1]。 ...
  • 4.限制了各个延时文本框的最大字7,显示列为4字节,以免字符串溢出错误。 5.★★★★添加了波特率可以随意手工设置为非标准值,例如 500bps,常用波特率仍然可选★★★★ 2005-3-8 1.修改发送程序,保证...
  • 268. Missing Number

    2016-11-07 21:56:09
    题意是给定一包含不同连续数字的数字,找出其中缺少的那个,...比如:00^01^10^11=00,同时利用相同异或结果为0这条件,可以构建一数组,来求出缺少的值,比如:**N1∧N2∧N3∧N2∧N3 =(N2∧N2)∧(N3∧N
  • 题意:强制在线次询问区间[l,r]内的最大连续异或和. 题解: 对序列进行前缀异或和,将问题转化成求区间[l-1,r]中的最大的两数异或和. 两个数的限制十分麻烦,尝试分块. 预处理数组f[i][j]表示第i块的最左端到j的这...
  • Kidnapper’s Matching Problem 题目链接 题目大意 ...使得a[l + i - 1] ^ b[i] 能在s中选一些数异或得到。 也就是a[l + i - 1] ^ b[i] 在s的线性基里出现。 题解 还是蠢啊,干不出来 假设 a ^ b 在s的线性
  • 一些神奇的小题目

    2010-11-14 17:12:00
    潜水久了,看到很有趣的小题目,这里做一个收集,很都已经是很有名了。以后有看到其他好玩的也会不断添进来。...2、一个数组存放了2n+1个整数,其中有n个数出现了2次,1个数出现了1次,找出出现1次...
  • 题目大概说给一序列,次询问区间异或和为k的连续子序列有多少。 莫队算法,利用异或的性质,通过前缀和求区间和,先处理出序列各个前缀和,然后每次区间转移时维护i以及i-1前缀和为某的个数并增加或减少对...
  • js冷知识之运算符

    2019-12-05 10:45:22
    且运算符(&&) 它往往用于多个表达式的求值,运算规则如下: 如果第一个运算子的布尔值 为true,则返回第二个运...异或运算有一个特殊运用,连续对两个数a 和 b进行三次异或运算,可以互换他们的值a^=b b^=a a^...
  • 从高到低枚举每一位,我要把这个序列分成m块,使每块中只有偶数个数该位为1。那么如果我把它分成尽可能的块使每块中该位有偶数个1,那么任意两块合并之后仍然满足每块中该位有偶数个1。分块过程满足贪心性质,可以...

空空如也

空空如也

1 2 3 4
收藏数 65
精华内容 26
关键字:

多个数连续异或