高斯消元&简单线性代数&线性基学习记录

最新推荐文章于 2024-07-22 21:51:19 发布

迷蒙之雨

最新推荐文章于 2024-07-22 21:51:19 发布

阅读量1.9k

点赞数 1

文章标签：线性代数算法

本文链接：https://blog.csdn.net/jwg2732/article/details/121151415

版权

线性代数，唉

高斯消元

P4035 [JSOI2008]球形空间产生器

题目描述

有一个球形空间产生器能够在n维空间中产生一个坚硬的球体。现在，你被困在了这个n维球体中，你只知道球面上n+1个点的坐标，你需要以最快的速度确定这个n维球体的球心坐标，以便于摧毁这个球形空间产生器。

解题思路

模板题，列出方程组高斯消元即可

#include<bits/stdc++.h>
using namespace std;
typedef double db;
const db eps=1e-8;
const int N = 20;
db C[N][N],B[N];
int n;
void Gauss()
{
	for(int i=1;i<=n;i++)
	{
		for(int j=i;j<=n;j++)
		{
			if(fabs(C[j][i])>eps)
			{
				for(int k=1;k<=n;k++)
				swap(C[i][k],C[j][k]);
				swap(B[i],B[j]);
			}
		}
		for(int j=1;j<=n;j++)
		{
			if(j==i) continue;
			db tmp=C[j][i]/C[i][i];
			for(int k=1;k<=n;k++)
			C[j][k]-=C[i][k]*tmp;
			B[j]-=B[i]*tmp;
		}
	}
}
bool check1()
{
	for(int i=1;i<=n;i++)
	{
		bool flag=1;
		for(int j=1;j<=n;j++)
		if(fabs(C[i][j])>eps)
		{
			flag=0;
			break;
		}
		if(flag==1&&fabs(B[i])>eps) return 1;
	}
	return 0;
}
bool check2()
{
	for(int i=1;i<=n;i++)
	{
		int cnt=0;
		for(int j=1;j<=n;j++)
		{
			if(fabs(C[i][j])>eps) cnt++;
		}
		if(cnt>1) return 1;
	}
	return 0;
}
db A[N][N];
int main()
{
	cin>>n;
	for(int i=1;i<=n+1;i++)
	for(int j=1;j<=n;j++)
	scanf("%lf",&A[i][j]);
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=n;j++)
		{
			C[i][j]=2*(A[i][j]-A[i+1][j]);
			B[i]+=A[i][j]*A[i][j]-A[i+1][j]*A[i+1][j];			
		}
	}
	Gauss();
	if(check1()) 
	{
		printf("No solution");
		return 0;
	}
	if(check2())
	{
		printf("Infinite group solutions");
		return 0;
	}
	for(int i=1;i<n;i++)
	printf("%.3lf ",B[i]/C[i][i]);
	printf("%.3lf",B[n]/C[n][n]);
	return 0;
}

开关问题

题目描述

有N个相同的开关，每个开关都与某些开关有着联系，每当你打开或者关闭某个开关的时候，其他的与此开关相关联的开关也会相应地发生变化，即这些相联系的开关的状态如果原来为开就变为关，如果为关就变为开。你的目标是经过若干次开关操作后使得最后N个开关达到一个特定的状态。对于任意一个开关，最多只能进行一次开关操作。你的任务是，计算有多少种可以达到指定状态的方法。（不计开关操作的顺序）

解题思路

开关的开和关可以用0/1表示,按或不按也可以用0/1表示，这样列出异或方程组，高斯消元即可，对于每个自由元有2中取值，所以答案就是 $2^k$ ，其中k为自由元个数

#include<bits/stdc++.h>
using namespace std;
const int N = 120;
int n;
int C[N][N],B[N];
int Gauss()
{
	int r=1,c=1;
	for(;c<=n;c++)
	{
		int t=r;
		for(int i=r+1;i<=n;i++)
		if(C[i][c]) t=i;
		if(!C[t][c]) continue;
		for(int i=c;i<=n;i++)
		swap(C[t][i],C[r][i]);
		swap(B[t],B[r]);
		for(int i=r+1;i<=n;i++)
		{
			if(C[i][c])
			{				
				B[i]^=B[r];
				for(int j=n;j>=c;j--)
				C[i][j]^=C[r][j];

			}
		}
		r++;
	}
	int res=1;
	if(r<=n)
	{
		for(int i=r;i<=n;i++)
		{
			if(B[i]) return -1;
			res*=2;
		}
	}
	return res;
}
void solve()
{
	memset(C,0,sizeof(C));
	memset(B,0,sizeof(B));
	cin>>n;
	for(int i=1;i<=n;i++)
	scanf("%d",&B[i]);
	for(int i=1;i<=n;i++)
	{
		int ed;
		scanf("%d",&ed);
		B[i]^=ed;
		C[i][i]=1;
	}
	int x,y;
	while(1)
	{
		scanf("%d%d",&x,&y);
		if(x==0&&y==0) break;
		C[y][x]=1;
	}
	int t=Gauss();
	if(t==-1) printf("Oh,it's impossible~!!\n");
	else printf("%d\n",t);
}
int main()
{
	freopen("switch.in","r",stdin);
	freopen("switch.out","w",stdout);
	int T;
	cin>>T;
	while(T--)
	{
		solve();
	}
	return 0;
}

脸哥最近在玩一款神奇的游戏，这个游戏里有 n 件装备，每件装备有 m 个属性，用向量zi(aj ,…,am) 表示
(1 <= i <= n; 1 <= j <= m)，每个装备需要花费 ci，现在脸哥想买一些装备，但是脸哥很穷，所以总是盘算着
怎样才能花尽量少的钱买尽量多的装备。对于脸哥来说，如果一件装备的属性能用购买的其他装备组合出（也就是
说脸哥可以利用手上的这些装备组合出这件装备的效果），那么这件装备就没有买的必要了。严格的定义是，如果
脸哥买了 zi1,…zip这 p 件装备，那么对于任意待决定的 zh，不存在 b1,…,bp 使得 b1zi1 + … + bpzi
p = zh（b 是实数），那么脸哥就会买 zh，否则 zh 对脸哥就是无用的了，自然不必购买。举个例子,z1 =(1; 2;
3);z2 =(3; 4; 5);zh =(2; 3; 4)，b1 =1/2，b2 =1/2，就有 b1z1 + b2z2 = zh，那么如果脸哥买了 z1 和 z2
就不会再买 zh 了。脸哥想要在买下最多数量的装备的情况下花最少的钱，你能帮他算一下吗？

解题思路

把装备看成向量，题目的限制就是要求线性空间的基，高斯消元并有限选择最少花费的向量作为主元就能保证答案最小

#include<bits/stdc++.h>
using namespace std;
const int N = 520;
typedef long long LL;
typedef double db;
typedef long double ldb;
const ldb eps = 1e-8;
ldb C[N][N];
int cost[N];
int n,m;
int cnt=0,ans=0;
void Gauss()
{
	for(int i=1;i<=m;i++)
	{
		int t=0;
		for(int j=cnt+1;j<=n;j++)
		{
			if(fabs(C[j][i])>eps&&(t==0||cost[j]<cost[t]))
			t=j;
		}
		if(t==0) continue;
		++cnt;
		ans+=cost[t];
		for(int j=1;j<=m;j++)
		swap(C[cnt][j],C[t][j]);
		swap(cost[cnt],cost[t]);
		for(int j=1;j<=n;j++)
		{
			if(j!=cnt&&fabs(C[j][i])>eps)
			{
				ldb dt=C[j][i]/C[cnt][i];
				for(int k=i;k<=m;k++)
				C[j][k]-=C[cnt][k]*dt;
			}
		}
	}
}
int main()
{
	freopen("test.in","r",stdin);
	freopen("test.out","w",stdout);
	cin>>n>>m;
	for(int i=1;i<=n;i++)
	for(int j=1;j<=m;j++)
	scanf("%llf",&C[i][j]);
	for(int i=1;i<=n;i++)
	scanf("%d",&cost[i]);
	Gauss();
	cout<<cnt<<' '<<ans<<endl;
	return 0;
}

P2962 [USACO09NOV]Lights G

题目描述

贝希和她的闺密们在她们的牛棚中玩游戏。但是天不从人愿，突然，牛棚的电源跳闸了，所有的灯都被关闭了。

贝希是一个很胆小的女生，在伸手不见拇指的无尽的黑暗中，她感到惊恐，痛苦与绝望。

她希望您能够帮帮她，把所有的灯都给重新开起来！她才能继续快乐地跟她的闺密们继续玩游戏！

牛棚中一共有N（1 <= N <= 35）盏灯，编号为1到N。

这些灯被置于一个非常複杂的网络之中。有M（1 <= M <= 595）条很神奇的无向边，每条边连接两盏灯。

每盏灯上面都带有一个开关。当按下某一盏灯的开关的时候，这盏灯本身，还有所有有边连向这盏灯的灯的状态都会被改变。状态改变指的是：当一盏灯是开著的时候，这盏灯被关掉；当一盏灯是关著的时候，这盏灯被打开。

问最少要按下多少个开关，才能把所有的灯都给重新打开。数据保证至少有一种按开关的方案，使得所有的灯都被重新打开。

解题思路

和上面的题类似，解出异或方程组，我们分析高斯消元的本质，其并没有改变这个矩阵的本质，因为我们的矩阵是邻接矩阵，所以我们高斯消元之后依旧是邻接矩阵，如果我们求的是上三角矩阵，则每个点之和它后面的点有关，所以对于主元我们直接按或不按判断，自由元dfs搜答案，倒叙dfs，可以保证前面的点对后面没有影响

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const LL N = 5030;
LL C[N][N],B[N];
LL n,m;
LL pos[N];
LL Gauss()
{
	LL cnt=0;
	for(LL i=1;i<=n;i++)
	{
		LL t=0;
		for(LL j=i;j<=n;j++)
		if(C[j][i])
		{
			t=j;
			break;
		}
		if(t==0) 
		{
			cnt++;
			continue;
		}
		for(LL k=1;k<=n;k++)
		swap(C[i][k],C[t][k]);
		swap(B[i],B[t]);
		cnt++;
		for(LL j=1;j<=n;j++)
		{
			if(j==i||!C[j][i]) continue;
			for(LL k=i+1;k<=n;k++)
			C[j][k]^=C[i][k];
			B[j]^=B[i];
			C[j][i]=0;
		}
	}
	return cnt;
} 
LL Ans=1e9;
LL Light[N];
void dfs(LL x,LL cnt)
{
	if(cnt>=Ans) return;
	if(x==0)
	{
		Ans=cnt;
		return;
	}
	if(C[x][x])
	{
		LL val=B[x];
		for(LL i=x+1;i<=n;i++)
		if(C[x][i]) val^=Light[i];
		dfs(x-1,cnt+val);
	}
	else
	{
		dfs(x-1,cnt);
		Light[x]=1;
		dfs(x-1,cnt+1);
		Light[x]=0;
	}
}
int main()
{
	cin>>n>>m;
	for(LL i=1;i<=n;i++)
	{
		C[i][i]=1;
		B[i]=1;
	}
	for(LL i=1;i<=m;i++)
	{
		LL x,y;
		scanf("%lld%lld",&x,&y);
		C[x][y]=C[y][x]=1;
	}
	if(Gauss()==0)
	{
		LL ans=0;
		for(LL i=1;i<=n;i++)
		ans+=B[i];
		cout<<ans;
		return 0;
	}
	dfs(n,0);
	cout<<Ans; 
	return 0;
}

SP2883 WIDGET - Widget Factory

题目描述

小部件工厂生产几种不同类型的小部件。

每个小部件都是精心制作而成。

制作小部件所需的时间取决于其类型：简单小部件仅需要 $3$ 天，但最复杂的小部件可能需要多达 $9$ 天。

工厂目前处于完全混乱的状态：最近，工厂被一位新主人收购，新主人解雇了几乎所有员工。

新员工对制作小部件毫无经验，没有人清楚制作每个不同类型的小部件分别需要多少天。

当客户订购小部件，工厂却无法告诉客户生产所需商品需要多少天时显得十分尴尬。

幸运的是，这里有记录记载了每个工人开始制作的日期，完成制作的日期以及制作的小部件型号。

但是问题是记录没有明确记载工人开始和完成工作的确切日期，只记录了该天是星期几。

尽管如此，这些信息也是有些帮助的：例如，如果一个人在星期二开始制作一个 $41$ 型小部件，并在周五完成，那么我们就知道了制作一个 $41$ 型小部件需要 $4$ 天时间（因为最多不超过 $9$ 天，所以不可能是 $11$ 天或更多）。

您的任务是从这些记录中（如果可能）找出制作不同类型的小部件所需的天数。

解题思路

我们把天数看成未知数，列出方程组，因为要%7，所以这是一个线性同余方程组，解得时候不能直接除，要用exgcd求逆元，细节挺多

线性基

[HDOJ3949]XOR

题目描述

有n个整数 $a_1,a_2...a_n$ 和m个询问，每个询问给出一个整数k，求从这n个数中选出若干数执行异或运算得到的整数集合中第k小的数是多少。

解题思路

线性基求异或第k大，详见OI-WIKI

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const LL N = 52000;
LL a[N],d[N];
LL tot=0;
LL n,m;
bool f=0;
void Insert(LL x)
{
	for(LL i=60;i>=0;i--)
	{
		if(x&(1ll<<i))
		{
			if(d[i]) x^=d[i];
			else 
			{
				d[i]=x;
				++tot;
				return;
			}
		}
	}
	f=1;
}
inline void work()
{
    for(LL i=0;i<=60;++i)
    {
        if(!d[i])continue;
        for(LL j=i+1;j<=60;++j)
            if(d[j]&(1ll<<i))d[j]=d[j]^d[i];
    }
}
LL k_th(LL k)
{

	if(f) k--;
	if(k>(1ll<<tot)-1) return -1;	
	LL ans=0;
	for(LL i=0;i<=60;i++)
	if(d[i])
	{
		if(k&1) ans=ans^d[i];
		k=k>>1;
	}
	return ans;
}
void solve()
{
	tot=0;
	f=0;
	memset(d,0,sizeof(d));
	cin>>n>>m;
	for(LL i=1;i<=n;i++)
	{
		scanf("%lld",&a[i]);
		Insert(a[i]);
	}
	work();
	for(LL i=1;i<=m;i++)
	{
		LL k;
		scanf("%lld",&k);
		printf("%lld\n",k_th(k));
	}
}
int main()
{
	freopen("xor.in","r",stdin);
	freopen("xor.out","w",stdout);
	LL T;
	cin>>T;
	while(T--)
	{
		solve();
	}
	return 0;
}

P4151 [WC2011]最大XOR和路径

在这里插入图片描述

解题思路

如果没有环，那么答案就是一条链，但是现在有了环，我们考虑从链上的一点走进环，发现一来一回，从链连向环的边被异或消掉了，所以只增加了环的异或和，所以我们dfs把所有的环找出来，加入线性基，然后找一条链使得从线性基中选择一些环异或它最大，这条链其实可以任意选，因为即使你选的不是最优的链，你也可以通过异或一个大环变成另一条链（因为这是无向图，所以两条链肯定会构成一个环）

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const LL N = 1e5+7;
struct edge
{
	LL y,v,next;
}e[2*N];
LL link[N],t=0;
void add(LL x,LL y,LL v)
{
	e[++t].y=y;
	e[t].v=v;
	e[t].next=link[x];
	link[x]=t;
}
LL n,m;
struct LinearBase
{
	LL d[100];
	LL cnt;
	LinearBase()
	{
		cnt=0;
		memset(d,0,sizeof(d));
	}
	void Insert(LL x)
	{
		for(LL i=60;i>=0;i--)
		{
			if(x&(1ll<<i))
			{
				if(d[i]) x^=d[i];
				else
				{
					cnt++;
					d[i]=x;
					return;
				}				
			}

		}
	}
	LL Max(LL x)
	{
		LL ans=x;
		for(LL i=60;i>=0;i--)
		if((ans^d[i])>ans) ans^=d[i];
		return ans;
	}
}Set;
bool vis[N];
LL dis[N];
void Find(LL x,LL dist)
{
	dis[x]=dist;
	vis[x]=1;
	for(LL i=link[x];i;i=e[i].next)
	{
		LL y=e[i].y;
		if(!vis[y]) Find(y,dist^e[i].v);
		else
		{
			LL val=dist^dis[y]^e[i].v;
			Set.Insert(val); 
		}
	}
}
int main()
{
	freopen("test.in","r",stdin);
	freopen("test.out","w",stdout);
	cin>>n>>m;
	for(LL i=1;i<=m;i++)
	{
		LL x,y,v;
		scanf("%lld%lld%lld",&x,&y,&v);
		add(x,y,v);
		add(y,x,v);
	}
	Find(1,0ll);
	printf("%lld\n",Set.Max(dis[n]));
	return 0;
}

P3857 [TJOI2008]彩灯

解题思路

我们把异或看成二进制数，则显然原集合能异或出的状态线性基也能异或出来，所以把这些状态加入线性基，最终设线性基中有x个元素，那么每个数可选可不选，共 $2^x$ 种答案

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N =100;
LL D[60];
int tot=0;
void Insert(LL x)
{
	for(int i=60;i>=0;i--)
	{
		if(x&(1ll<<i))
		{
			if(D[i]) x^=D[i];
			else
			{
				D[i]=x;
				++tot;
				break;
			}
		}
	}
}
int n,m;
char s[N];
LL change()
{
	LL res=0;
	for(int i=1;i<=n;i++)
	if(s[i]=='O') res|=(1ll<<i);
	return res;
}
int main()
{
	cin>>n>>m;
	for(int i=1;i<=m;i++)
	{
		scanf("%s",s+1);
		LL x=change();
		Insert(x);
	}
	LL ans=(1ll<<tot);
	cout<<ans%2008;
	return 0;
}

P3292 [SCOI2016]幸运数字

解题思路

看到异或最大值可以想到线性基，而树上两点间的查询可以想到树剖，所以用树剖维护两点间的线性基，复杂度有点大， $O(nlog^4)$ ，需要开O2，但是有更好的做法，因为没有修改所以完全可以用倍增，复杂度 $O(nlog^3)$ ，轻松通过，不过我还是写的是树剖

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 20020;
struct node
{
	int y,next;
}e[2*N];
int link[N],t=0;
void add(int x,int y)
{
	e[++t].y=y;
	e[t].next=link[x];
	link[x]=t;
}
int n,q;
LL Luck[N];
struct LinearBase
{
	LL D[63];
	LinearBase()
	{
		memset(D,0,sizeof(D));
	}
	void Insert(LL x)
	{
		for(int i=60;i>=0;i--)
		{
			if(x&(1ll<<i))
			{
				if(D[i]) x^=D[i];
				else
				{
					D[i]=x;
					break;
				}
			}
		}
	}
	LL Ask()
	{
		LL ans=0;
		for(int i=60;i>=0;i--)
		if((ans^D[i])>ans) ans^=D[i];
		return ans;
	}
}tree[4*N];
void Merge(LinearBase &x,LinearBase &y)
{
	for(int i=60;i>=0;i--)
	{
		if(y.D[i]!=0)
		{
			x.Insert(y.D[i]); 
		}
	}
}
int dep[N],fa[N],top[N],siz[N],son[N];
void dfs(int x,int pre)
{
	fa[x]=pre;
	dep[x]=dep[pre]+1;
	siz[x]=1;
	for(int i=link[x];i;i=e[i].next)
	{
		int y=e[i].y;
		if(y==pre) continue;
		dfs(y,x);
		siz[x]+=siz[y];
		if(siz[y]>siz[son[x]]) son[x]=y;
	}
}
int seq[N],dfn[N],tot=0;
void Exdfs(int x,int topth)
{
	dfn[x]=++tot;
	top[x]=topth;
	seq[tot]=x;
	if(!son[x]) return;
	Exdfs(son[x],topth);
	for(int i=link[x];i;i=e[i].next)
	{
		int y=e[i].y;
		if(y==son[x]||y==fa[x]) continue;
		Exdfs(y,y);
	}
}
void build(int k,int l,int r)
{
	if(l==r)
	{
		tree[k].Insert(Luck[seq[l]]);
		return; 
	}
	int mid=(l+r)>>1;
	build(k<<1,l,mid);
	build(k<<1|1,mid+1,r);
	tree[k]=tree[k<<1];
	Merge(tree[k],tree[k<<1|1]); 
}
LinearBase Ask(int k,int l,int r,int L,int R)
{
	if(L<=l&&r<=R) return tree[k];
	int mid=(l+r)>>1;
	LinearBase res;
	if(L<=mid) 
	{
		LinearBase tmp=Ask(k<<1,l,mid,L,R);
		Merge(res,tmp);
	}
	if(R>mid)
	{
		LinearBase tmp=Ask(k<<1|1,mid+1,r,L,R);
		Merge(res,tmp);
	}
	return res;
}
LL Query(int x,int y)
{
	LinearBase res;
	while(top[x]!=top[y])
	{
		if(dep[top[x]]<dep[top[y]]) swap(x,y);
		LinearBase tmp=Ask(1,1,n,dfn[top[x]],dfn[x]);
		Merge(res,tmp);
		x=fa[top[x]];
	}
	if(dep[x]>dep[y]) swap(x,y);
	LinearBase tmp=Ask(1,1,n,dfn[x],dfn[y]);
	Merge(res,tmp);
	return res.Ask();
}
int main()
{
	cin>>n>>q;
	for(int i=1;i<=n;i++)
	scanf("%lld",&Luck[i]);
	for(int i=1;i<n;i++)
	{
		int x,y;
		scanf("%d%d",&x,&y);
		add(x,y);
		add(y,x);
	}
	dfs(1,0);
	Exdfs(1,1);
	build(1,1,n);
	while(q--)
	{
		int x,y;
		scanf("%d%d",&x,&y);
		printf("%lld\n",Query(x,y));
	}
	return 0; 
}

P3733 [HAOI2017]八纵八横

压轴题，和WC的最大XOR路径类似，但是加了修改边权和加边删边的操作，而线性基并不很好支持删除，修改边权可以看成先删除这条边，再加入一条新边，而说到维护动态的图，我们可以想到线段树分治，所以把每一条边持续的区间映射到线段树上，并维护线性基，这样就只有加入操作，没有删除操作
其余的和那道题类似

#include<bits/stdc++.h>
using namespace std;
const int N = 1120;
typedef bitset<N> bit;
vector<bit> tree[4*N];
int n,m,q;
struct edge
{
	int y,next;
	bit v;
}e[4*N];
int link[N],t=0;
struct node
{
	int x,y;
	bit v;
}seg[N];
int Mx=1000;
bit dis[N];
struct LB
{
	bit D[N];
	void insert(bit x)
	{
		for(int i=Mx;i>=0;i--)
		{
			if(x[i])
			{
				if(!D[i].any())
				{
					D[i]=x;
					break;
				}
				else x^=D[i];
			}
		}
	}
}Fst;
void add(int x,int y,bit v)
{
	e[++t].y=y;
	e[t].v=v;
	e[t].next=link[x];
	link[x]=t;
} 
char s[N];
bit read()
{
	bit x;
	scanf("%s",s);
	int len=strlen(s)-1;
	for(int i=0;i<=len;i++)
	x[i]=s[len-i]-'0';
	return x;
}
bool vis[N];
void dfs(int x,int pre)
{
	vis[x]=1;
	for(int i=link[x];i;i=e[i].next)
	{
		int y=e[i].y;
		if(y==pre) continue;
		if(!vis[y])
		{
			dis[y]=dis[x]^e[i].v;
			dfs(y,x);
		}
		else Fst.insert(dis[y]^dis[x]^e[i].v) ;
	}
}
void Add(int k,int l,int r,int L,int R,bit x)
{
	if(L<=l&&r<=R)
	{
		tree[k].push_back(x);
		return;
	}
	int mid=(l+r)>>1;
	if(L<=mid) Add(k<<1,l,mid,L,R,x);
	if(R>mid) Add(k<<1|1,mid+1,r,L,R,x);
}
bit Ans;
void Print(LB x)
{
	Ans.reset();
	int i;
	for(i=Mx;i>=0;i--)
	if(x.D[i].any()) break;
	if(i<0)
	{
		printf("0\n");
		return;
	}
	int pos=i;
	for(int j=i;j>=0;j--)
	if(x.D[j].any()&&!Ans[j]) Ans^=x.D[j];
	for(int j=pos;j>=0;j--)
	if(Ans[j]==0) printf("0");
	else printf("1");
	printf("\n");
}
void solve(int k,int l,int r,LB now)
{
	for(int i=0;i<tree[k].size();i++)
	now.insert(tree[k][i]);
	if(l==r)
	{
		Print(now);
		return;
	}
	int mid=(l+r)>>1;
	solve(k<<1,l,mid,now);
	solve(k<<1|1,mid+1,r,now);
}
int st[N];
int main()
{
	cin>>n>>m>>q;
	bit v;
	for(int i=1;i<=m;i++)
	{
		v.reset();
		int x,y;
		scanf("%d%d",&x,&y);
		v=read();
		add(x,y,v);
		add(y,x,v);
	}
	int top=0;
	dfs(1,0);
	for(int i=1;i<=q;i++)
	{
		scanf("%s",s+1);
		if(s[1]=='C')
		{
			int x;
			scanf("%d",&x);
			Add(1,1,q,st[x],i-1,dis[seg[x].x]^dis[seg[x].y]^seg[x].v);
			if(s[2]=='h')
			{
				st[x]=i;
				seg[x].v.reset();
				seg[x].v=read();	
			}
			else st[x]=0;
		} 
		else
		{
			st[++top]=i;
			scanf("%d %d",&seg[top].x,&seg[top].y);
			seg[top].v=read();
		}
	}
	for(int i=1;i<=top;i++)
	if(st[i]) Add(1,1,q,st[i],q,dis[seg[i].x]^dis[seg[i].y]^seg[i].v);
	Print(Fst);
	if(q!=0) solve(1,1,q,Fst);
	return 0;
}

迷蒙之雨

关注

1
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
高斯消元&简单线性代数&线性基学习记录

线性代数，唉高斯消元P4035 [JSOI2008]球形空间产生器题目描述有一个球形空间产生器能够在n维空间中产生一个坚硬的球体。现在，你被困在了这个n维球体中，你只知道球面上n+1个点的坐标，你需要以最快的速度确定这个n维球体的球心坐标，以便于摧毁这个球形空间产生器。解题思路模板题，列出方程组高斯消元即可#include<bits/stdc++.h>using namespace std;typedef double db;const db eps=1e-8;const
复制链接

扫一扫