151209 总结

Mstdream

于 2015-12-09 15:42:36 发布

阅读量304

点赞数

文章标签：乱搞优化主席树树套树

本文链接：https://blog.csdn.net/lcrtest/article/details/50237183

版权

做过的。网络流+离散化，实现耗了很久

对拍+std 写了一个小时= =果然离散化就是恶心（还是自己太弱了）

暴力搜吧

各种启发式搞了30分

然而正解是状压DP

我们可以把序列切割搞这个问题

每个块可以维护一个平衡树，整体用一个块状链表套起来

然后yjq说可以二分（卧槽）%yjq

YYY说可以线段树套线段树（%yyy）

然后被卡常数了 70

100+30+70,果然太弱

//Copyright(c)2015 liuchenrui
#include<cstdio>
#include<ctime>
#include<iostream>
#include<algorithm>
#include<cstring>
#define inf 1000000000
#define o(e) ((((e)-1)^1)+1)
using namespace std;
inline void splay(int &v)
{
	v=0;char c=0;int p=1;
	while(c<'0' || c>'9'){if(c=='-')p=-1;c=getchar();}
	while(c>='0' && c<='9'){v=(v<<3)+(v<<1)+c-'0';c=getchar();}
	v*=p;
}
struct Edge
{
    int to,len,next;
}edge[5000000];
int first[1002],size;
int deep[1002];
int dl[1002];
int a[301],b[301],c[301];
int p[1002],tot;
inline void addedge(int x,int y,int z)
{
	//if(z!=0)fprintf(stderr,"%d %d %d\n",x,y,z);
    size++;
    edge[size].to=y;
    edge[size].next=first[x];
    first[x]=size;
    edge[size].len=z;
}
bool bfs(int s,int t)
{
    memset(deep,-1,sizeof deep);
    int head=0,tail=1;
    dl[1]=s;
    deep[s]=0;
    while(head!=tail)
    {
        head++;
        for(int u=first[dl[head]];u;u=edge[u].next)
        {
            if(edge[u].len>0 && deep[edge[u].to]==-1)
            {
                dl[++tail]=edge[u].to;
                deep[edge[u].to]=deep[dl[head]]+1;
            }
        }
    }
    if(deep[t]==-1)return false;
    return true;
}
int dfs(int now,int flow,int t)
{
    if(now==t)return flow;
    int F=0;
    for(int u=first[now];u&&flow>0;u=edge[u].next)
    {
        if(edge[u].len>0 && deep[edge[u].to]-deep[now]==1)
        {
            int ret=dfs(edge[u].to,min(edge[u].len,flow),t);
            F+=ret;
            edge[u].len-=ret;
            edge[o(u)].len+=ret;
            flow-=ret;
        }
    }
    if(!F)deep[now]=-5;
    return F;
}
int maxflow(int s,int t)
{
    int ret=0;
    while(bfs(s,t))
        ret+=dfs(s,inf,t);
    return ret;
}
int n,m;
int main()
{
	freopen("arrange.in","r",stdin);
	freopen("arrange.out","w",stdout);
	int T;splay(T);
	while(T--)
	{
		splay(n),splay(m);int sig=0;tot=0;
		size=0;memset(first,0,sizeof first);
		for(int i=1;i<=n;i++)
		{
			splay(a[i]),splay(b[i]),splay(c[i]);
			b[i]+=2,c[i]+=2;
			p[++tot]=b[i],p[++tot]=c[i];
			sig+=a[i];
		}
		sort(p+1,p+tot+1),unique(p+1,p+tot+1);
		tot=0;while(p[tot]<p[tot+1])tot++;
		for(int i=1;i<=n;i++)
		{
			int now;
			for(now=1;;now++)if(p[now]==b[i])break;
			while(p[now]!=c[i])
			{
				addedge(i,now+300,p[now+1]-p[now]);
				addedge(now+300,i,0);now++;
			}
			addedge(0,i,a[i]);
			addedge(i,0,0);
		}
		for(int i=1;i<=tot-1;i++)
		{
			addedge(i+300,1001,(p[i+1]-p[i])*m);
			addedge(1001,i+300,0);
		}
		maxflow(0,1001)==sig?puts("Yes"):puts("No");
	}
}

//Copyright(c)2015 liuchenrui
#include<cstdio>
#include<ctime>
#include<iostream>
#include<algorithm>
#include<cstring>
#define inf 1000000000
using namespace std;
inline void splay(int &v)
{
	v=0;char c=0;int p=1;
	while(c<'0' || c>'9'){if(c=='-')p=-1;c=getchar();}
	while(c>='0' && c<='9'){v=(v<<3)+(v<<1)+c-'0';c=getchar();}
	v*=p;
}
int n,m;
int mp[11][11];
bool used[11][11];
bool vis[11][11];
double cost[11][11];
int ans=inf;
struct node
{
	double cost;
	int tx,ty;
};
bool comp(const node &a,const node &b)
{
	return a.cost<b.cost;
}
void dfs(int x,int y,int sum)
{
	if(clock()>=1900)return;
	vis[x][y]=true;
	ans=min(ans,sum);
	node nodes[100];int tot=0;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			if(used[i][j]||vis[i][j])continue;
			if(vis[i-1][j]||vis[i][j-1]||vis[i+1][j]||vis[i][j+1])
				nodes[++tot]=(node){cost[i][j],i,j};
		}
	}
	sort(nodes+1,nodes+tot+1,comp);
	for(int i=1;i<=tot;i++)
	{
		dfs(nodes[i].tx,nodes[i].ty,sum+mp[nodes[i].tx][nodes[i].ty]);
	}
	vis[x][y]=false;
}
void maincost()
{
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			for(int l=1;l<=n;l++)
			{
				for(int r=1;r<=m;r++)
				{
					if(i==l && j==r)continue;
					cost[l][r]+=mp[i][j]*5/(abs(i-l)+abs(j-r));
				}
			}
		}
	}
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			cost[i][j]+=mp[i][j]*2;
		}
	}
}
int main()
{
	freopen("cheapest.in","r",stdin);
	freopen("cheapest.out","w",stdout);
	splay(n),splay(m);bool flag=false;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			splay(mp[i][j]);
			if(mp[i][j]<0)flag=true;
		}
	}
	maincost();
	/*for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			printf("%d ",cost[i][j]);
		}
		printf("\n");
	}
	return 0;*/
	if(!flag)puts("0"),exit(0);
	for(int T=1;T<=n*m;T++)
	{
		int tx,ty;
		double tmp=inf;
		for(int i=n;i>=1;i--)
		{
			for(int j=m;j>=1;j--)
			{
				if(mp[i][j]>0)continue;
				//dfs(i,j,mp[i][j]);
				if(cost[i][j]<tmp)tmp=cost[i][j],tx=i,ty=j;
			}
		}
		used[tx][ty]=true;
		dfs(tx,ty,mp[tx][ty]);
		if(clock()>=1950)break;
	}
	
	cout<<ans<<endl;
}

//Copyright(c)2015 liuchenrui
#include<cstdio>
#include<ctime>
#include<iostream>
#include<algorithm>
#include<cstring>
#define min(a,b) ((a)<(b)?(a):(b))
#define ll long long
#define inf 1000000000 
/***************
n*sqrt(n)*log(n)
***************/
//using namespace std;

inline void splay(int &v)
{
	v=0;char c=0;int p=1;
	while(c<'0' || c>'9'){if(c=='-')p=-1;c=getchar();}
	while(c>='0' && c<='9'){v=(v<<3)+(v<<1)+c-'0';c=getchar();}
	v*=p;
}
int P;
int ls[6000000],rs[6000000],fa[6000000];
int size[6000000],num[6000000],val[6000000];
int ass[300010],sum[300010];
int a[300010],b[300010],r[300010];
int nodecount;
int root;
int tot;
int m;
ll ans=0;
void merge(int s,int mid,int t)
{
    int k=s,i=s,j=mid+1;
	while(i<=mid && j<=t)
	if(a[i]>a[j])r[k++]=a[j++],ans+=mid-i+1;
	else r[k++]=a[i++];
	while(i<=mid)r[k++]=a[i++];
	while(j<=t)r[k++]=a[j++];
	for(i=s;i<=t;i++)a[i]=r[i];
}
void mergesort(int l,int r)
{
	if(l==r)return;
    int mid=l+r>>1;
    mergesort(l,mid);
    mergesort(mid+1,r);
    merge(l,mid,r);
}
void update(int now)
{
	size[now]=size[ls[now]]+size[rs[now]]+num[now];
}
void left_rotate(int now)
{
	if(now==root)return;
	int f=fa[now],ff=fa[fa[now]],b=ls[now];
	if(f==root)
	{
		root=now;
		ls[now]=f;fa[f]=now;rs[f]=b;
		if(b!=0)fa[b]=f;
	}
	else
	{
		fa[now]=ff;if(ls[ff]==f)ls[ff]=now;else rs[ff]=now;
		ls[now]=f;fa[f]=now;rs[f]=b;
		if(b!=0)fa[b]=f;
	}
	update(f),update(now);
}
void right_rotate(int now)
{
	if(now==root)return;
	int f=fa[now],ff=fa[fa[now]],b=rs[now];
	if(f==root)
	{
		root=now;
		rs[now]=f;fa[f]=now;ls[f]=b;
		if(b!=0)fa[b]=f;
	}
	else
	{
		fa[now]=ff;if(ls[ff]==f)ls[ff]=now;else rs[ff]=now;
		rs[now]=f;fa[f]=now;ls[f]=b;
		if(b!=0)fa[b]=f;
	}
	update(f),update(now);
}
int newnode()
{
	++tot;
	size[tot]=1;
	num[tot]=1;
	return tot;
}
void insert(int now,int x)
{
	if(x==val[now])
	{
		num[now]++;
		update(now);
		return;
	}
	if(x<val[now])
	{
		if(ls[now]!=0)insert(ls[now],x);
		else
		{
			ls[now]=newnode();
			fa[tot]=now;
			val[tot]=x;
		}
		//if(priority[now]>priority[ls[now]])
		//if(!(rand()&4))
		if(false)
			right_rotate(ls[now]);
	}
	else
	{
		if(rs[now]!=0)insert(rs[now],x);
		else
		{
			rs[now]=newnode();
			fa[tot]=now;
			val[tot]=x;
		}
		//if(priority[now]>priority[rs[now]])
		//if(!(rand()&4))
		if(false)
			left_rotate(rs[now]);
	}
	update(now);
}
int calc(int now,int x)
{
	if(now==0)return 0;
	if(x<val[now])return calc(ls[now],x);
	if(x==val[now])return size[ls[now]];
	return  calc(rs[now],x)+size[ls[now]]+num[now];
}
int n;
int rootcnt;
void build(int l,int r,int &ass)
{
	ass=++tot;
	val[ass]=inf+1;
	val[++tot]=-inf-1;
	ls[ass]=ass+1;fa[ass+1]=ass;
	size[ass]=2;size[ass+1]=1;
	num[ass]=num[ass+1]=1;
	root=ass;
	for(int i=l;i<=r;i++)
	{
		insert(ass,a[i]);
		ass=root;
	}
}
int fuck(int x)
{
	int now=1;int ret=0;
	for(int i=1;now<=n;now+=P,i++)
	{
		if(now+P-1>=x)break;
		else ret+=i+P-now-calc(ass[i],a[x]+1)+1;
	}
	for(int i=now;i<=min(now+P-1,n);i++)
	{
		if(i<x && a[i]>a[x])ret++;
		if(i>x && a[i]<a[x])ret++;
	}
	now+=P;
	for(int i=now/P+1;now<=n;now+=P,i++)
	{
		ret+=calc(ass[i],a[x])-1;
	}
	return ret;
}
#include<math.h>
int main()
{
	freopen("counting.in","r",stdin);
	freopen("counting.out","w",stdout);
	srand(time(0));
	splay(n);P=(int)sqrt(n);
	for(int i=1;i<=n;i++)
	{
		splay(a[i]);b[i]=a[i];
	}
	mergesort(1,n);
	//std::cerr<<clock()<<std::endl;
	for(int i=1;i<=n;i++)a[i]=b[i];
	for(int i=1;i<=min(i+P-1,n);i+=P)
	{
		build(i,min(i+P-1,n),ass[++rootcnt]);
	}
	splay(m);
	//std::cerr<<clock()<<std::endl;
	for(int T=1;T<=m;T++)
	{
		int x,y;
		splay(x),splay(y);
		int l=fuck(x);
		a[x]=y;
		for(int i=1,now=1;i<=n;i+=P,now++)
		{
			if(i+P-1>=x)
			{
				build(i,min(i+P-1,n),ass[now]);
				break;
			}
		}
		int r=fuck(x);
		ans+=(ll)(r-l);
		printf("%I64d\n",ans);
	//	if(T%100==1)std::cerr<<T/100<<":"<<clock()<<std::endl;
	}
	//std::cerr<<clock()<<std::endl;
	//std::cerr<<tot<<std::endl;
}