noi2009

最新推荐文章于 2021-12-13 14:02:50 发布
最新推荐文章于 2021-12-13 14:02:50 发布
阅读量404 收藏
点赞数
分类专栏： NOI
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/worldbuster/article/details/8943700
版权

变换序列

题目：

变换序列

分析：

二分图匹配。

至于字典序最小，从后往前进行匹配即可

程序：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <memory.h>
#include <fstream>

using namespace std;

const int Max_N = 10010;

int n;
int edge[Max_N][2];

void Init()
{
	scanf("%d", &n);
	for(int i = 0; i < n; i ++)
	{
		int x;
		scanf("%d", &x);
		edge[i][0] = (i + x) % n;
		edge[i][1] = (i + n - x) % n;
		if(edge[i][0] > edge[i][1])
			swap(edge[i][0], edge[i][1]);
	}
}

int flag[Max_N];
bool visited[Max_N];

bool Dfs(int x)
{
	for(int i = 0; i < 2; i ++)
	{
		int y = edge[x][i];
		if(! visited[y])
		{
			visited[y] = true;
			if(flag[y] == -1 || Dfs(flag[y]))
			{
				flag[y] = x;
				return true;
			}
		}
	}
	return false;
}

int res[Max_N];
void Output()
{
	for(int i = 0; i < n; i ++)
		res[flag[i]] = i;
	for(int i = 0; i < n - 1; i ++)
		printf("%d ", res[i]);
	printf("%d\n", res[n - 1]);
}

void Solve()
{
	memset(flag, -1, sizeof(flag));
	int cnt = 0;
	for(int i = n - 1; i >= 0; i --)
	{
		memset(visited, false, sizeof(visited));
		if(Dfs(i))
			cnt ++;
	}
	if(cnt < n)
		printf("No Answer\n");
	else
		Output();
}

int main()
{
//	freopen("transform.in", "r", stdin);
//	freopen("transform.out", "w", stdout);
	Init();
	Solve();
	return 0;
}

诗人小G

waiting...

二叉查找树

题目：

分析：

动归题
分析题目可以知道，由于只能更改权值，而数据值大小不变，且整棵树满足儿子节点的数据值大于父节点的数据值。因此，不论权值如何修改，整棵树从左到右的排列顺序不会改变。
于是，
（1）将给定的节点先按权值排序，并进行离散化。然后按数据值排序。
（2）设 dp[ i, j, k ] 表示排序后可用来表示这颗树的数列在区间 [ i, j ] 中，所有权值都大于 k 的最小访问代价。
易知，dp [ i, j, k ] = min (dp[ i, u - 1, k ] + dp[ u + 1, j, k ] + K + sum [ j ] - sum [ i - 1 ]，dp[ i, u - 1, k ] + dp[ u + 1, j, k ] + sum[ j ] - sum[ i - 1 ])
其中，u 表示所枚举出的在区间 [ i, j ] 中的根。sum [ i ] 表示 1～ i 的频度总和
前一种表示 u 这个节点的权值小于 k，因此，需要调整。
后一种表示 u 这个节点的权值大于 k，因此，不需要调整。
因为树的访问代价包括 sigma ( 频度 X 深度 )。又因为 dp 是由下向上一层层更新，这样每次加上 sum [ j ] - sum [ i - 1]，可以保证 sigma 的正确性

程序

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <algorithm>
#include <memory.h>

using namespace std;

#define LL long long

const int Max_N = 80;
const int inf = 987654321;

struct Tree
{
    int data, weight, freq;
}tree[Max_N];

int n, ext;
int sum[Max_N];

bool Cmp1(Tree a, Tree b)
{
    return a.data < b.data;
}

bool Cmp2(Tree a, Tree b)
{
    return a.weight < b.weight;
}

void Init()
{
    scanf("%d%d", &n, &ext);
    for(int i = 1; i <= n; i ++)
        scanf("%d", &tree[i].data);
    for(int i = 1; i <= n; i ++)
        scanf("%d", &tree[i].weight);
    for(int i = 1; i <= n; i ++)
        scanf("%d", &tree[i].freq);

    sort(tree + 1, tree + n + 1, Cmp2);
    for(int i = 1; i <= n; i ++)
        tree[i].weight = i;
    sort(tree + 1, tree + n + 1, Cmp1);

    sum[0] = 0;
    for(int i = 1; i <= n; i ++)
        sum[i] = sum[i - 1] + tree[i].freq;
}

LL dp[Max_N][Max_N][Max_N];

LL Dp(int i, int j, int k)
{
    if(i > j)
        dp[i][j][k] = 0;
    if(dp[i][j][k] > -1)
        return dp[i][j][k];
    for(int u = i; u <= j; u ++)
    {
        if(tree[u].weight >= k)
            if(dp[i][j][k] == -1 || dp[i][j][k] > Dp(i, u - 1, tree[u].weight) + Dp(u + 1, j, tree[u].weight))
                dp[i][j][k] = Dp(i, u - 1, tree[u].weight) + Dp(u + 1, j, tree[u].weight);
        if(dp[i][j][k] == -1 || dp[i][j][k] > Dp(i, u - 1, k) + Dp(u + 1, j, k) + ext)
            dp[i][j][k] = Dp(i, u - 1, k) + Dp(u + 1, j, k) + ext;
    }
    if(dp[i][j][k] > -1)
        dp[i][j][k] += sum[j] - sum[i - 1];
    return dp[i][j][k];
}

LL Dp()
{
    for(int i = 1; i <= n; i ++)
    {
        for(int j = 0; j < i; j ++)
            for(int k = 0; k < Max_N; k ++)
                dp[i][j][k] = 0;
    }
    for(int l = 1; l <= n; l ++)
    {
        for(int i = 1; i + l - 1 <= n; i ++)
        {
            int j = i + l - 1;
            for(int k = 0; k <= n; k ++)
            {
                for(int u = i; u <= j; u ++)
                {
                    if(tree[u].weight >= k)
                        if(dp[i][j][k] == -1 || dp[i][j][k] > Dp(i, u - 1, tree[u].weight) + Dp(u + 1, j, tree[u].weight))
                            dp[i][j][k] = Dp(i, u - 1, tree[u].weight) + Dp(u + 1, j, tree[u].weight);
                    if(dp[i][j][k] == -1 || dp[i][j][k] > Dp(i, u - 1, k) + Dp(u + 1, j, k) + ext)
                        dp[i][j][k] = Dp(i, u - 1, k) + Dp(u + 1, j, k) + ext;
                }
                if(dp[i][j][k] > -1)
                    dp[i][j][k] += sum[j] - sum[i - 1];
            }
        }
    }
}

void Solve()
{
    memset(dp, -1, sizeof(dp));
//    printf("%lld\n", dp[1][n][0]);
    printf("%lld\n", Dp(1, n, 0));
}

int main()
{
    Init();
    Solve();
    return 0;
}

植物大战僵尸

题目：

分析：

网络流题：最大闭权子图
（1）我们根据每个植物的保护关系建立一张图。其中，每行中靠右的植物一定保护靠左的植物。
（2）我们发现，如果一些植物构成环。那么这一定是不能被僵尸吃掉的。建图把它们删掉。
（3）由于需要求出的是 score 总和最大。因此，如果把所建的边全部反向，会发现要求答案，只要求出最大闭权子图就可以了。因为闭合图是指图中每个点所指向的点也在图内，如果边没有反向，那么最左边的植物是必选的，但是右侧的点不一定选，与题意不符。而如果反向，那么最右边的植物是必选的，而较左侧的点可以不选，符合题意。

程序：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <memory.h>
#include <queue>
#include <fstream>

using namespace std;

const int Max_N = 610;
const int inf = ~0U >> 1;

int n, m;

struct Edge
{
    int y, flow, next;
}pvz[Max_N * Max_N * 2], edge[Max_N * Max_N * 5];
int len_e, root_e[Max_N];
int deg_in[Max_N], len_p, root_p[Max_N];

int s, t;
int score[Max_N * Max_N];

void Add_Edge_(int x, int y, int z)
{
	edge[len_e] = (Edge){y, z, root_e[x]};
	root_e[x] = len_e ++;
}

void Add_Edge(int x, int y, int z)
{
	Add_Edge_(x, y, z);
	Add_Edge_(y, x, 0);
}

void Add_Pvz(int x, int y)//contain the node who points to itself
{
	pvz[len_p] = (Edge) {y, 0, root_p[x]};
	root_p[x] = len_p ++;
	deg_in[y] ++;
}

int Point2Id(int x, int y)
{
    return x * m + y;
}

void Make_Pvz()//transposed graph
{
	memset(deg_in, 0, sizeof(deg_in));
	memset(root_p, -1, sizeof(root_p));
	len_p = 0;
    for(int i = 0; i < n; i ++)
    {
        for(int j = 0; j < m; j ++)
        {
            scanf("%d", &score[Point2Id(i, j)]);
            if(j + 1 < m)//(i, j) -> (i, j + 1)
            	Add_Pvz(Point2Id(i, j + 1), Point2Id(i, j));
//            	Add_Pvz(Point2Id(i, j), Point2Id(i, j + 1));

            int tmp;
            scanf("%d", &tmp);
            for(int k = 0; k < tmp; k ++)
            {
                int x, y;
                scanf("%d%d", &x, &y);//(x, y) -> (i, j)
                Add_Pvz(Point2Id(i, j), Point2Id(x, y));
//                Add_Pvz(Point2Id(x, y), Point2Id(i, j));
            }
        }
    }

    n = n * m;
}

bool choose[Max_N];

void Topo_Sort()
{
	queue <int> q;
	memset(choose, false, sizeof(choose));
	for(int i = 0; i < n; i ++)
		if(deg_in[i] == 0)
			q.push(i);
	while(!q.empty())
	{
		int x = q.front();
		q.pop();
		choose[x] = true;
		for(int p = root_p[x]; p != -1; p = pvz[p].next)
		{
			int y = pvz[p].y;
			deg_in[y] --;
			if(deg_in[y] == 0)
				q.push(y);
		}
	}
}

int remain;

void Make_Graph()
{
	s = n;
	t = s + 1;
	remain = 0;
	len_e = 0;
	memset(root_e, -1, sizeof(root_e));
	for(int i = 0; i < n; i ++)
	{
		if(choose[i])
		{
			if(score[i] > 0)
			{
				Add_Edge(s, i, score[i]);
				remain += score[i];
			}
			else
				Add_Edge(i, t, -score[i]);
			for(int p = root_p[i]; p != -1; p = pvz[p].next)
			{
				int y = pvz[p].y;
				if(choose[y])
					Add_Edge(y, i, inf);
			}
		}
	}
}

int d[Max_N];
int seq[Max_N], l, r;

bool Bfs()
{
	memset(d, 0, sizeof(d));
	l = r = 0;
	seq[r ++] = s;
	d[s] = 1;
	while(l < r)
	{
		int i = seq[l ++];
		for(int p = root_e[i]; p != -1; p = edge[p].next)
		{
			int y = edge[p].y;
			if(!d[y] && edge[p].flow > 0)
			{
				d[y] = d[i] + 1;
				seq[r ++] = y;
				if(y == t)
					return true;
			}
		}
	}
	return false;
}

int Dinic(int i, int flow)
{
	if(i == t)
		return flow;
	int res = flow;
	for(int p = root_e[i]; p != -1; p = edge[p].next)
		if(edge[p].flow > 0 && d[i] + 1 == d[edge[p].y])
		{
			int tmp = Dinic(edge[p].y, min(res, edge[p].flow));
			if(tmp == 0)
				d[edge[p].y] = 0;
			edge[p].flow -= tmp;
			edge[p ^ 1].flow += tmp;
			res -= tmp;
		}
	return flow - res;
}

void Init()
{
    scanf("%d%d", &n, &m);
    s = n * m;
    t = s + 1;
    Make_Pvz();
    Topo_Sort();
    Make_Graph();
}

void Solve()
{
    int ans = 0;
    while(Bfs())
	    ans += Dinic(s, inf);
	printf("%d\n", remain - ans);
}

int main()
{
/*
	freopen("pvz.in", "r", stdin);
	freopen("pvz.out", "w", stdout);
*/
	Init();
	Solve();
    return 0;
}


管道取珠

题目：

分析：

组合数学
设 f [ x1, y1, x2, y2 ] 表示分别采用两种方法X，Y同时得到相同的珠子的排列的个数。对于每一个结果A，它有 |X| * |Y| 中可能性。其中 |X| = |Y| = a [ i ]
因此，sigma (ai ^ 2) 就表示采用两种方法，经过各种步骤达到最终结果的总和

程序：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <memory.h>
 
using namespace std;
 
const int Max_N = 510;
const int Mod = 1024523;
 
int n_up, n_down;
char sign_up[Max_N], sign_down[Max_N];
 
void Init()
{
    scanf("%d%d", &n_up, &n_down);
    scanf("%s%s", sign_up + 1, sign_down + 1);
}
 
int dp[Max_N][Max_N][Max_N];
 
void Add(int i1, int j1, int i2, int delta)
{
    dp[i1][j1][i2] = (dp[i1][j1][i2] + delta) % Mod;
}
 
void Solve()
{
    memset(dp, 0, sizeof(dp));
    dp[0][0][0] = 1;
    for(int t = 0; t < n_up + n_down; t ++)
    {
        for(int i1 = 0; i1 <= t; i1 ++)
        {
            if(i1 > n_up)
                break;
            int j1 = t - i1;
            for(int i2 = 0; i2 <= t; i2 ++)
            {
                if(i2 > n_up)
                    break;
                int j2 = t - i2;
                int delta = dp[i1][j1][i2];
                if(!delta)
                    continue;
                if(sign_up[i1 + 1] == sign_up[i2 + 1])
                    Add(i1 + 1, j1, i2 + 1, delta);
                if(sign_up[i1 + 1] == sign_down[j2 + 1])
                    Add(i1 + 1, j1, i2, delta);
                if(sign_down[j1 + 1] == sign_up[i2 + 1])
                    Add(i1, j1 + 1, i2 + 1, delta);
                if(sign_down[j1 + 1] == sign_down[j2 + 1])
                    Add(i1, j1 + 1, i2, delta);
            }
        }
    }
    printf("%d\n", dp[n_up][n_down][n_up]);
}
 
int main()
{
    Init();
    Solve();
    return 0;
}


worldbuster
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【总结】NOI 2009
慢慢前行，跨越预言
08-19 730
这是一个oier的自测，满足下自己小小的虚荣（向铜牌奔跑），仅是一个oier，没有参加过什么noi，就算p（noip），也只是鸟时去了一次。。。。 -----------------------------------------------------------------
[NOI2009]变换序列
aoanping0730的博客
03-18 68
Description Input Output Sample Input 5 1 1 2 2 1 Sample Output 1 2 4 0 3 HINT 30%的数据中N≤50； 60%的数据中N≤500； 100%的数据中N≤10000。 二分图匹配 匈牙利算法的原理是冲突时替换 不过要求字典序最小，一个点会连出2条边，...
管道取珠 NOI2009比赛真题
srh20的博客
12-13 135
传送门 考察：dp动态规划，dp的优化：滚动数组 思路： 因为ai是组成第i个序列的方案数，那么ai^2是两个装置都取得第i个序列的 方案数。 共有四个维度， i:第一个人在第一个管子里取的球数， j:第一个人在第二个管子里取的球数， k:第二个人在第一个管子里取的球数， l:第二个人在第二个管子里取的球数。 由于数据限制，因此最多只能三维，那么因为对于每个人，球的总数为i+j,因此l=i+j-k。 同时滚动数组优化。 最开始now=0, f[i][j][k]表示已经取了i颗珠子，第一个装置第一行取了j个珠
NOI2009 植物大战僵尸
a6t2007的博客
01-11 172
题目描述 题解： 由于干每棵植物之前需要先干掉它右面的植物和保护他的植物， 我们可以发现这是最大权闭合子图问题。 简单提一下。 闭合子图，指这个子图中所有的点只会指向子图中的点。 最大权，指这些点有点权，要求得到的闭合子图点权之和最大。 解决办法是，$S$向正点权的点连容量为点权的边，负点权的点向$T$连容量为点权相反数的边。 然后正点权之和-得到的最大流即为最大权...
【Luogu1912】【NOI2009】诗人小G（动态规划）
小蒟蒻yyb的博客
06-15 683
题面 洛谷 题解 原来NOINOINOI这么多神仙题。。。 考虑一个极其明显的dpdpdp 设f[i]f[i]f[i]表示前iii个句子产生的最小代价 转移也很显然，就懒得写了。 仔细思考一下，转移具有单调性。 但是我们用单调队列似乎无法直接维护。 继续思考一下，我们的转移结果一定是从前面一个位置转移过来的 并且一定是一段连续的位置都由那个位置转移过来。 同时，如果iii从j...
【BZOJ1564】[NOI2009]二叉查找树【区间DP】
BraketBN
04-26 942
【题目链接】 这是一棵Treap，而且我们知道BST的中序遍历的数据值是递增的，那么我们按照数据值排个序，就得到中序遍历了。然后就变成区间DP啦。 设dp[l][r][m]表示，区间[l, r]的节点组成的树中的，根节点的权值≥m的最小代价。 然后枚举根节点转移。 （1）将根节点i的权值修改为m，有dp[l][r][m] = dp[l][i - 1][m] + dp[i + 1][r][m
noi2009测试数据
09-13
【标题】"noi2009测试数据"是指全国青少年信息学奥林匹克竞赛（NOI）2009年所使用的测试数据集。这个数据集主要用于检验和评估参赛选手编写的程序在解决特定问题时的正确性和效率。NOI是中国最高级别的青少年编程...
NOI2009.rar_.noi20_Noi2009 P_noi20
09-23
【标题】"NOI2009.rar_.noi20_Noi2009 P_noi20" 涉及的是2009年全国青少年信息学奥林匹克（NOI）的比赛资料，其中包含了选手的解题报告，源代码，问题注解以及解答。 【描述】"最新noi2099解题报告.包含源程序.标注...
NOI 国家集训队论文 1999-2009 2013-2017
04-18
这些资料主要涵盖了1999年至2017年间NOI（全国青少年信息学奥林匹克竞赛）国家集训队的论文，以及2014年和2015年的NOI冬令营讲者PPT，是信息学竞赛领域的重要参考资料。NOI是中国最高级别的中学生信息学竞赛，而国家...
NOI 2005-2009试题
03-29
"NOI 2005-2009试题"的资源包含了这五年间的全部竞赛题目，对于学习信息学和准备参赛的学生来说是宝贵的参考资料。 NOI赛事通常涵盖算法设计、编程技能以及问题解决能力等多方面。比赛试题通常分为几个类别，包括但...
noi试题2009b
12-06
NOI 2009 第二试 植物大战僵尸题目解析 本题是全国信息学奥林匹克竞赛（NOI）2009 第二试的题目，属于传统编程题型。该题目模拟了 Plants vs. Zombies 游戏的游戏机制，要求编程者制定一套 Zombies 的进攻方案，以...
[NOI2009]诗人小G（决策单调性）
xyyxyyx的博客
07-17 182
题意 有n个字符串，将其按顺序分组，每组的代价是总长度与常数L的差的绝对值的P次方，要使所有组的代价之和最小 即 ans=∑k(∑i∈groupklen[i])Pans=\sum_{k}(\sum_{i \in group_k}len[i])^Pans=k∑​(i∈groupk​∑​len[i])P 最小化ansansans。 思路 首先我们考虑暴力。 令 sum[i]=∑j=1ilen[j]su...
[NOI2009]管道取珠
weixin_30668887的博客
07-17 89
题目描述 管道取珠是小X很喜欢的一款游戏。在本题中，我们将考虑该游戏的一个简单改版。游戏画面如图1所示： （图1） 游戏初始时，左侧上下两个管道分别有一定数量的小球（有深色球和浅色球两种类型），而右侧输出管道为空。每一次操作，可以从左侧选择一个管道，并将该管道中最右侧的球推入右边输出管道。 例如：我们首先从下管道中移一个球到输出管道中，将得到图2所示的情况。 （图2） ...
NOIP2009年普及组初赛试题答案及解析
城南蝈蝈
10-27 6919
原文链接请点这： 一、单项选择题（共20题，每题1.5分，共计30分。每题有且仅有一个正确答案。） 1、 关于图灵机下面的说法哪个是正确的：（ D） A.图灵机是世界上最早的电子计算机。 B.由于大量使用磁带操作，图灵机运行速度很慢。 C.图灵机是英国人图灵发明的，在二战中为破译德军的密码发挥了重要作用。 D.图灵机只是一个理论上的计算模型。 【解析】所谓的图灵机就是指一个抽象的机器，它有一条无限长的纸带，纸带分成了一个一个的小方格，每个方格有不同的颜色。有一个机器头在纸带上移来移去。机器头有一组内部状态，
【[NOI2009]管道取珠】
weixin_30846599的博客
01-01 106
——\(shallwe\)：这道题是\(noipDay2T2\)难度 好一个\(Day2T2\)难度啊，我觉得我可以退役了 平方和好像没有什么办法可以快速统计，于是考虑转化一下 我们可以将题意转化成这样 求有序对\((A,B)\),取法\(A\)可以和取法\(B\)得到相同的结果 也就是可以将题目抽象成一个人进行这个游戏两遍，能得到同样结果的方案数是多少 之后我们可以设计出这样的\(dp...
bzoj 1565: [NOI2009]植物大战僵尸 （最大权闭合子图+tarjan+拓扑序）
clover_hxy的博客
01-16 316
1565: [NOI2009]植物大战僵尸 Time Limit: 10 Sec  Memory Limit: 64 MB Submit: 2345  Solved: 1081 [Submit][Status][Discuss] Description Input Output 仅包含一个整数，表示可以获得的最大能源收入。注意，你也可以选择不进行任何攻击，这样能源
097N04L-VB一款N-Channel沟道DFN8(3X3)的MOSFET晶体管参数介绍与应用说明
最新发布
07-15
097N04L-VB；Package：DFN8(3X3)；Configuration：Single-N-Channel；VDS：40V；VGS：20（±V）；Vth：2.5V；RDS(ON)=6mΩ@VGS=4.5V；RDS(ON)=4.5mΩ@VGS=10V；ID：40A；Technology：Trench；
[NOI2009]变换序列（二分图匹配）
05-25
题目描述 给出一个由 $n$ 个数排成的序列，你可以进行如下操作： 交换相邻的两个数。 将该序列中的第 $k$ 个数改为 $x$。 你的任务是将该序列变成一个等差数列。...第一行包含两个整数 $n$ 和 $m$，表示序列长度和...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值