NOI 2010 题解

最新推荐文章于 2023-03-31 21:04:14 发布

xsy97051

最新推荐文章于 2023-03-31 21:04:14 发布

阅读量819

点赞数

分类专栏： NOI历年

本文链接：https://blog.csdn.net/qq_25471829/article/details/46312449

版权

NOI历年专栏收录该内容

13 篇文章 0 订阅

订阅专栏

能量采集

(传送门)

题意

可以证明点(x,y)与(0,0)所连线段上不包含原点有的点为gcd(x,y)，问题就变成了求gcd(x,y)(1 <= x <= n,1 <= y <= m)的和

分析

80分算法(x，y<=1000):
位于(x,y)的点产生的分值是：Gcd(x,y)；问题转换成求Gcd(x,y)。答案为Σ(gcd(x,y)*2-1)，枚举x和y即可。复杂度O(n^2logn),代码不再给出，大家都会写
100分算法(x,y<=100000):
Gcd(x,y)=D，D<=10^5范围不是很大，倒过来考虑，可以求满足Gcd(x,y)=d的(x,y)的个数。
有Σ(gcd(x,y)*2-1)=Σ(F[d]*(d*2-1))，其中F[d]表示满足Gcd(x,y)=d的(x,y)的个数。
考虑以d为公约数的(x,y)的个数g[d]，显然有g[d]=[n/d]*[m/d];
根据容斥原理有：f[d]=g[d]-Σ(f[d*i]) (2<=i<=[min(n,m)/d])；
这样只需要倒过来从min(n,m)反推到1求解即可。时间复杂度O(nlogn)

代码

#include <bits/stdc++.h>
using namespace std;

long long f[100005];

int main()
{
    long long n,m;
    cin>>n>>m;
    if(n>m) swap(n,m);
    long long sum=0;
    for(long long i=n;i>=1;i--)//反向思维枚举d=gcd(x,y)
    {
        f[i]=(n/i)*(m/i);//所有以d为公约数的(x,y)个数为cnt[d]=(n/d)*(m/d)
        for(int j=i+i;j<=n;j+=i)//所有以d为最大公约数的(x,y)的个数为Σf[d]-f[i*d](减去所有以d的倍数为公约数的个数)
            f[i]-=f[j];
        sum+=f[i]*(2*i-1);
    }
    cout<<sum<<endl;
    return 0;
}

超级钢琴

(传送门)

题意

n个音符，第i个的美妙度为Ai(可正可负)。一个“超级和弦”包含的音符个数不少于L且不多于R。定义超级和弦的美妙度为其包含的所有音符的美妙度之和。两个超级和弦被认为是相同的，当且仅当这两个超级和弦所包含的音符集合是相同的。一首由k个超级和弦组成的乐曲，要求该乐曲由k个不同的超级和弦组成。我们定义一首乐曲的美妙度为其所包含的所有超级和弦的美妙度之和。求美妙度最大值是多少。

分析

以开始位置为i的区间，它的结束位置只能是[i+L−1,i+R−1]之间。假设要求以i开始的区间，它的最大得分是多少，即sum[j]−sum[i−1]最大，显然只要RMQ(i+L−1,i+R−1)求出最大的sum[j]即可。
设开始位置为i，结束位置为[l,r]，最大得分点为j，最大得分为v，将i，l，r，j，v存入一个节点。
枚举i=1 to n，将所有节点放进一个优先队列。那么此时队首的元素就是得分最大的区间。
依次将队首元素取出，此时对于点i来说，点j已经不能用了。原区间分裂成[l,j−1],[j+1,r]两个区间，
我们再用RMQ分别算出新区间的v和j，将其加入优先队列。重复以上步骤直到取出了k个元素。

代码

#include <bits/stdc++.h>
using namespace std;

const int MAXN=500000+10;

int n,k,minlen,maxlen;
long long arr[MAXN];
long long sum[MAXN];

int ST[MAXN][20];
int IDX[MAXN][20];
void initST()
{
    for(int i=1;i<=n;i++)
    {
        ST[i][0]=sum[i];
        IDX[i][0]=i;
    }
    for(int j=1;j<=20;j++)
        for(int i=1;i<=n;i++)
            if(i+(1<<j)-1<=n)
            {
                if(ST[i][j-1] > ST[i+(1<<j-1)][j-1])
                {
                    ST[i][j]=ST[i][j-1];
                    IDX[i][j]=IDX[i][j-1];
                } else
                {
                    ST[i][j]=ST[i+(1<<j-1)][j-1];
                    IDX[i][j]=IDX[i+(1<<j-1)][j-1];
                }
            }
}
int query(int a,int b)
{
    int k=log(b-a+1) / log(2);
    return max(ST[a][k],ST[b-(1<<k)+1][k]);
}
int query_idx(int a,int b)
{
    int k=log(b-a+1) / log(2);
    if(ST[a][k] > ST[b-(1<<k)+1][k]) return IDX[a][k];
    else return IDX[b-(1<<k)+1][k];
}

struct Nod
{
    int i,idx,l,r,v;
    Node()
    {}
    Node(int a,int b,int c,int d,int e)
        : i(a),idx(b),l(c),r(d),v(e)
        {}
    bool operator < (const Node &n) const
    {
        return v n.v;
    }
};

priority_queue<Node> q;

int main()
{
    scanf("%d%d%d%d",&n,&k,&minlen,&maxlen);
    for(int i=1;i<=n;i++)
    {
        scanf("%lld",&arr[i]);
        sum[i]=sum[i-1]+arr[i];
    }
    initST();
    for(int i=1;i+minlen-1<=n;i++)
    {
        int l=i+minlen-1;
        int r=min(n,i+maxlen-1);
        int v=query(l,r);
        int idx=query_idx(l,r);
        q.push(Node(i,idx,l,r,v-sum[i-1]));
    }
    long long ans=0;
    while(k--)
    {
        Node cur=q.top();
        q.pop();
        ans+=cur.v;
        if(cur.idx>cur.l)
        {
            int l=cur.l;
            int r=cur.idx-1;
            int v=query(l,r);
            int idx=query_idx(l,r);
            q.push(Node(cur.i,idx,l,r,v-sum[cur.i-1]));
        }
        if(cur.idx<cur.r)
        {
            int l=cur.idx+1;
            int r=cur.r;
            int v=query(l,r);
            int idx=query_idx(l,r);
            q.push(Node(cur.i,idx,l,r,v-sum[cur.i-1]));
        }
    }
    printf("%lld\n",ans);
    return 0;
}

海拔

(传送门)

题意

n×n个区域,包括(n+1)×(n+1)个交叉路口和2n×(n+1)条双向道路，每条道路连接主干道上两个相邻的交叉路口。知道每条道路两个方向的人流量。每一个交叉路口都有不同的海拔高度值，每向上爬h的高度，就需要消耗h的体力。下坡不需要耗费体力。因此若一段道路的终点海拔减去起点海拔的值为h(h可能是负数)，那么一个人经过这段路所消耗的体力是max{0, h}，西北角的交叉路口海拔为0，东南角的交叉路口海拔为1.可以任意假设其他路口的海拔高度，求耗费总体力和的最小值。

分析

总的代价是由各个节点的海拔决定的，而s与t都已事先确定好了，我们需要做的就是确定各个点的海拔。由左上到右下海拔的趋势是逐渐升高的，不会出现峰或谷，因为这样会支付两边来人的钱。发现由a到b，如果海拔增高就一定会一次性从0增到1，因为当出现h[a]<h[b]<h[c] 逐渐升高的情况时，假设w[a,b]>w[b,c]，则这样设置海拔的代价会大于h[a]==h[b]==0,h[c]=1的情况，所以图中节点的海拔非0即1，且左上那一团为0，右下那一团为1。发现要寻找的就是那一条01节点接壤的线，而这条线正好将这些点分为了两个集合，s与t也恰好在这两个集合，这就是最小割模型了。这么多点用网络流一定会TLE，但是这个图是一个规则的图，可以把最小割转化为对偶图的最短路，spfa就快的飞起了。

代码

#include <bits/stdc++.h>
using namespace std;

const int MAX=1000000+5;
const int MAXN=300000+5;
int n;
int s,t;
int tot=1;
int first[MAXN],to[MAX*2],nex[MAX*2],w[MAX*2];
inline void addEdge(int a,int b,int c)
{
	nex[++tot]=first[a];
	first[a]=tot;
	to[tot]=b;
	w[tot]=c;
}

int dis[MAXN];
int Stack[MAX*24+10],vis[MAXN];
inline void spfa()
{
	memset(dis,0x3f,sizeof(dis));
	int head=0,tail=1;
    dis[s]=0,Stack[1]=s,vis[s]=1;
	while(head<tail)
    {
		head++;
		for(int k=first[Stack[head]];k;k=nex[k])
			if(dis[to[k]]>dis[Stack[head]]+w[k])
            {
				dis[to[k]]=dis[Stack[head]]+w[k];
				if(!vis[to[k]])
                {
					tail++;
					Stack[tail]=to[k];
					vis[to[k]]=1;
				}
			}
		vis[Stack[head]]=0;
	}
}

int main()
{
	scanf("%d",&n);
	s=0;
	t=n*n+1;
    int x;
	//W to E
	for(int j=1;j<=n;j++)
    {
		scanf("%d",&x);
		addEdge(j,t,x);
	}
	for(int i=2;i<=n;i++)
		for(int j=1;j<=n;j++)
        {
			scanf("%d",&x);
			addEdge((i-1)*n+j,(i-2)*n+j,x);
		}
	for(int j=1;j<=n;j++)
    {
		scanf("%d",&x);
		addEdge(s,n*(n-1)+j,x);
	}
	//N to S
	for(int i=1;i<=n;i++)
    {
		scanf("%d",&x);
		addEdge(s,(i-1)*n+1,x);
		for(int j=2;j<=n;j++)
        {
			scanf("%d",&x);
			addEdge((i-1)*n+j-1,(i-1)*n+j,x);
		}
		scanf("%d",&x);
		addEdge(i*n,t,x);
	}
	//E to W
	for(int j=1;j<=n;j++)
    {
		scanf("%d",&x);
		addEdge(t,j,x);
	}
	for(int i=2;i<=n;i++)
		for(int j=1;j<=n;j++)
        {
			scanf("%d",&x);
			addEdge((i-2)*n+j,(i-1)*n+j,x);
		}
	for(int j=1;j<=n;j++)
    {
		scanf("%d",&x);
		addEdge(n*(n-1)+j,s,x);
	}
	//S to N
	for(int i=1;i<=n;i++)
    {
		scanf("%d",&x);
		addEdge((i-1)*n+1,s,x);
		for(int j=2;j<=n;j++)
        {
			scanf("%d",&x);
			addEdge((i-1)*n+j,(i-1)*n+j-1,x);
		}
		scanf("%d",&x);
		addEdge(t,i*n,x);
	}
	
	spfa();
	
	printf("%d",dis[t]);
	return 0;
}

航空管制

(传送门)

题意

航班共有n个，起飞序列还存在两类限制条件：
第一类（最晚起飞时间限制）：编号为i的航班起飞序号不得超过ki;
第二类（相对起飞顺序限制）：存在一些相对起飞顺序限制(a, b)，表示航班a的起飞时间必须早于航班b，即航班a的起飞序号必须小于航班b的起飞序号。是否可以计算出一个可行的起飞序列。第二个问题则是，在考虑两类限制条件的情况下，如何求出每个航班在所有可行的起飞序列中的最小起飞序号(BZOJ的数据有问题所以此题给的链接是VIJOS的)

分析

第一问，对每个节点，肯定要比自己的后继先，在此基础上越往后越好，可以将一个节点i的k更新为min(k[i],k[j]-1)j为i的后继
更新的时候要按照拓扑序来，否则有可能更新不完全，即他儿子还没更新完就更新它了，最后按照这个k排序输出即可，可以证明这样一定满足条件。
第二问，对于每个点iDFS一下，那么它肯定要放在他这棵子树的所有点的后面，记当前答案为ans ，已经放了cnt个点了，那么初始cnt=ans，然后每访问一个没放到序列中的点，cnt++，对于其他的点，按照第一问求得的k从小到大访问，有可能存在点的k>ans，意味着这个点一定要放在ans前面，那么ans++，可能存在点的k<=cnt，也就是说点i无论如何一定要放在这个点后面，否则怎样都无法满足，那么ans=k+1

代码

#include <bits/stdc++.h>
using namespace std;

const int maxn=2000+10;
int n,m,cnt,pos[maxn],A[maxn];
bool vis[maxn];

struct PLANE
{
    int idx,k;
    bool operator <(const PLANE &o)const
    {
        return k<o.k;
    }
} p[maxn];
struct Edge  
{
    int next,to;
} edges[maxn*10];
int tot,head[maxn]
void addEdge(int a,int b)
{
    edges[++tot].next=(Edge){head[a],b};
    head[a]=tot;
}

bool Deal(int u)
{
    for(int i=head[u];i;i=edges[i].next)
        if(i&1)
        {
            int v=edges[i].to;
            p[u].k=min(p[u].k,p[v].k-1);
        }
}

void Solve1()
{
    for(int j=1;j<=n;j++)
        for(int i=1;i<=n;i++)
            Deal(i);
    sort(p+1,p+1+n);
    for(int i=1;i<n;i++)
        printf("%d ",p[i].idx);
    printf("%d\n",p[n].idx);
}

int Count(int u)
{
    int ret=0,v;vis[u]=true;
    for(int i=head[u];i;i=edges[i].next)
        if(!(i&1)&&!vis[v=edges[i].to])
            ret+=Count(v);
    return ret+1;
}

void Solve2()
{
    for(int i=1;i<=n;i++)
    {
        memset(vis,0,sizeof(vis));
        int ans=Count(i);
        cnt=ans;
        for(int j=1;j<=n;j++)
            if(!vis[p[j].idx])
            {
                cnt++;
                if(p[j].k<=ans)ans++;
                else if(cnt>p[j].k)ans=p[j].k+1;
            }
        A[i]=ans;
    }
    for(int i=1;i<n;i++)
        printf("%d ",A[i]);
    printf("%d\n",A[n]);
}

  
int main()
{
    scanf("%d%d",&n,&m);int a,b;
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&p[i].k),p[i].idx=i;
    }
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d",&a,&b);
        addEdge(a,b);
        addEdge(b,a); 
    }
    Solve1();
    Solve2();
    return 0;
}

旅行路线

(传送门)

题意

n × m的矩阵(n≤3)，每一个格子为一个展馆，不同展馆排队时间的长短也不相同。每一个展馆(x,y)若Tx,y=1，这个展馆需要排很长时间的队，否则不需要排队。
路线有以下限制：
1. 参观完于(x,y)后，下一个是一个相邻的且未被参观过的展馆(x',y')即 |x-x'|+|y-y'|=1；

2. 起点的x=1或x=n或y=1或y=m

制定了一个长度为n*m的 01 序列L，第i个参观的展馆(x,y)满足Tx,y=Li。

求可行的旅行路线总数mod 11192869。

分析

裸的搜索好像有30分，在其基础上，加上一点剪枝(当走过的区域将整个图分成了两个或两个以上的连通块时，直接舍去)即可过70分。然后看大犇的插头dp才能AC，贴上别人AC代码

代码

#include <bits/stdc++.h>
using namespace std;

const int MAXN=3,MAXM=50,MAXNUM=MAXN*MAXM+10;
const int MOD=11192869;

void inc(int &a,int b)
{
    if((a+=b)>=MOD) a-=MOD;
}

int N,M;
struct status
{
    bitset<MAXNUM+1> use;
    int a[MAXN],w;
    int pre_suc(int t)
    {
        if(t<0) return 3;
        return (t==1 || use[t-1])<<1 | (t==N*M || use[t+1]);
    }
    int pre_suc_a(int t)
    {
        return pre_suc(a[t]);
    }
    void add(int j);

    bool adj(int j,int k)
    {
        return a[j]==k || (j && a[j-1]==k);
    }
    void work(int j,int k)
    {
        if(!use[k] && use[k-1]==adj(j,k-1) && use[k+1]==adj(j,k+1))
        {
            int t=a[j];
            use[k]=1;
            a[j]=k;
            add(j+1);
            a[j]=t;
            use[k]=0;
        }
    }
};

map<int,status> f[MAXN+1];
void status::add(int j)
{
    int t=0;
    for(int i=0;i<N;i++)
        t=(t*MAXNUM+max(a[i],0))*4+pre_suc_a(i);
    if(f[j].count(t)) inc(f[j][t].w,w);
    else f[j][t]=*this;
}

int T[MAXN][MAXM],L[MAXNUM];
int main()
{
    scanf("%d%d",&N,&M);
    for(int i=0;i<N;i++)
        for(int j=0;j<M;j++)
            scanf("%d",T[i]+j);
    for(int i=1;i<=N*M;i++)
        scanf("%d",L+i);

    map<int,status>::iterator it,tmp;
    status init;
    init.a[0]=init.a[1]=init.a[2]=-1,init.w=1;
    init.add(N);
    for(int i=0;i<M;i++)
    {
        f[0].swap(f[N]);
        for(int j=1;j<=N;j++)
            f[j].clear();
        for(it=f[0].begin();it!=f[0].end();)
            if(it->second.pre_suc_a(N-1)==0)
            {
                tmp=it++;
                f[0].erase(tmp);
            }
            else it++;

        for(int j=0;j<N;j++)
        {
            bool side= i==0 || i==M-1 || j==0 || j==N-1;
            for(it=f[j].begin();it!=f[j].end();it++)
            {
                status &now=it->second;
                int up=now.pre_suc_a(j);
                int left= j ? now.pre_suc_a(j-1) : 3;
                if(up==3 && left)
                {
                    if(i || j)
                    {
                        k= now.a[i?j:j-1]&1 ? 2 : 1;
                        if(k<1+!side)
                            k+=2;
                        for(int ; k<=N*M; k+=2)
                            if(L[k]==T[j][i])
                                now.work(j,k);
                    }
                    else 
                    {
                        for(int k=1; k<=N*M; k++)
                        if(L[k]==T[j][i])
                            now.work(j,k);
                    }
                }
                else if(up==3 || left)
                {
                    int mid=now.a[left ? j : j-1];
                    for(int k=mid-1; k<=N*M && k<=mid+1; k+=2)
                        if(k>0 && (side || k>1)
                        && L[k]==T[j][i])
                            now.work(j,k);
                }
                else if(abs(now.a[j-1]-now.a[j])==2)
                {
                    k=(now.a[j-1]+now.a[j])>>1;
                    if(L[k]==T[j][i])
                        now.work(j,k);
                }
            }
        }
    }

    int ans=0;
    for(it=f[N].begin();it!=f[N].end();it++)
        inc(ans,it->second.w);
    printf("%d\n",ans);
    return 0;
}