【HDU5749 BestCoder Round 84C】【ST-RMQ？NO！暴力跳法or单调栈法 + 贡献思维】Colmerauer 所有子矩阵size乘鞍点权值和

最新推荐文章于 2019-03-25 09:37:45 发布
最新推荐文章于 2019-03-25 09:37:45 发布
阅读量990 收藏 1
点赞数 2
分类专栏： 题库-HDU 单调栈 复杂度计算 文章标签： 题库-HDU 单调栈 复杂度计算
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/snowy_smile/article/details/52020721
版权

Colmerauer

 
 Accepts: 32
 
 Submissions: 121
 Time Limit: 10000/5000 MS (Java/Others)
 
 Memory Limit: 131072/131072 K (Java/Others)
问题描述 
Peter有一个n \times mn×m的矩阵MM. 定义S(a,b)S(a,b)为MM的所有大小为a \times ba×b的子矩阵的权值和. 一个矩阵的权值是这个矩阵所有鞍点的值的和. 在矩阵中, 一个数在所在行中是唯一的最小值, 在所在列中是唯一的最大值, 则被称为鞍点. 帮助Peter找出所有S(a,b)S(a,b)的值.

注意: 本题中鞍点的定义可能和你所知的有所不同.
输入描述 
输入包含多组数据, 第一行包含一个整数TT表示测试数据组数. 对于每组数据:

第一行包含两个整数nn和mm (1 \le n, m \le 1000)(1≤n,m≤1000)表示矩阵的大小.

接下来nn行每行包含mm个非负整数, 表示矩阵MM的每一行 (MM中每个元素都不超过10^610​6​​).
输出描述 
对于每组数据, 输出一个整数W = (\displaystyle\sum_{a=1}^{n}\sum_{b=1}^{m}{a \cdot b \cdot S(a,b)}) \text{ mod } 2^{32}W=(​a=1​∑​n​​​b=1​∑​m​​a⋅b⋅S(a,b)) mod 2​32​​.
输入样例 
3
2 2
1 1
1 1
3 3
1 2 3
4 5 6
7 8 9
3 3
1 2 1
2 3 1
4 5 2
输出样例 
4
600
215

【HDU5749 BestCoder Round 84C】【ST-RMQ？NO！暴力跳法 + 贡献思维】Colmerauer 所有子矩阵size乘鞍点权值和

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<string>
#include<ctype.h>
#include<math.h>
#include<set>
#include<map>
#include<vector>
#include<queue>
#include<bitset>
#include<algorithm>
#include<time.h>
using namespace std;
void fre() { freopen("c://test//input.in", "r", stdin); freopen("c://test//output.out", "w", stdout); }
#define MS(x,y) memset(x,y,sizeof(x))
#define MC(x,y) memcpy(x,y,sizeof(x))
#define MP(x,y) make_pair(x,y)
#define ls o<<1
#define rs o<<1|1
typedef long long LL;
typedef unsigned long long UL;
typedef unsigned int UI;
template <class T1, class T2>inline void gmax(T1 &a, T2 b) { if (b>a)a = b; }
template <class T1, class T2>inline void gmin(T1 &a, T2 b) { if (b<a)a = b; }
const int N = 1010, M = 0, Z = 1e9 + 7, ms63 = 0x3f3f3f3f;
int casenum, casei;
int n, m;
UI a[N][N];
UI c[N + N];
UI d[N][N];
int lft[N][N];
int rgt[N][N];
int top[N][N];
int bot[N][N];
void RMQinit()
{
	for (int i = 1; i <= n; ++i)
	{
		for (int j = 1; j <= m; ++j)
		{
			if (j == 1)lft[i][j] = 1;
			else
			{
				int p = j - 1;
				while (p >= 1 && a[i][p] > a[i][j])p = lft[i][p] - 1;
				lft[i][j] = p + 1;
			}
			if (i == 1)top[i][j] = 1;
			else
			{
				int p = i - 1;
				while (p >= 1 && a[p][j] < a[i][j])p = top[p][j] - 1;
				top[i][j] = p + 1;
			}
		}
	}

	for (int i = n; i >= 1; --i)
	{
		for (int j = m; j >= 1; --j)
		{
			if (j == m)rgt[i][j] = m;
			else
			{
				int p = j + 1;
				while (p <= m && a[i][p] > a[i][j])p = rgt[i][p] + 1;
				rgt[i][j] = p - 1;
			}
			if (i == n)bot[i][j] = n;
			else
			{
				int p = i + 1;
				while (p <= n && a[p][j] < a[i][j])p = bot[p][j] + 1;
				bot[i][j] = p - 1;
			}
		}
	}
}

int main()
{
	//fre();
	for (int i = 1; i <= 2000; ++i)c[i] = c[i - 1] + i;
	for (int i = 1; i <= 1000; ++i)
	{
		for (int j = 1; j <= 1000; ++j)
		{
			d[i][j] = d[i][j - 1] + c[i + j - 1] - c[j - 1];
		}
	}
	scanf("%d", &casenum);
	for (casei = 1; casei <= casenum; ++casei)
	{
		scanf("%d%d", &n, &m);
		for (int i = 1; i <= n; ++i)
		{
			for (int j = 1; j <= m; ++j)
			{
				scanf("%u", &a[i][j]);
			}
		}
		RMQinit();
		UI ans = 0;
		for (int i = 1; i <= n; ++i)
		{
			for (int j = 1; j <= m; ++j)
			{
				int topp = top[i][j];
				int bott = bot[i][j];
				int lftt = lft[i][j];
				int rgtt = rgt[i][j];
				ans += d[i - topp + 1][bott - i + 1] * d[j - lftt + 1][rgtt - j + 1] * a[i][j];
			}
		}
		printf("%u\n", ans);
	}
	return 0;
}
/*
【trick&&吐槽】
复杂度，复杂度，复杂度！
复杂度包括——
思维复杂度
代码复杂度
时空复杂度。

这道题上来就想到求出每个点，作为鞍点，向左向右可以延展多少，向上向下可以延展多少。
不过是想用ST-RMQ实现。
而ST-RMQ的复杂度多了一个log(n)

妈蛋，zimpha的数据竟然不水了，多个log的算法就tle了。
>.<虽然节省了思维复杂度，却浪费了代码复杂度与时空复杂度，最后没有AC。
还是酌情想出高效的算法比较好。

【题意】
给你一个n*m的矩阵。
我们定义S(a,b)为所有大小为a*b的子矩阵的权值和。
一个子矩阵的权值和，定义为——
该矩阵中有所有鞍点的权值和。

一个矩阵中的鞍点，定义为——
该点同行的所有点中，该点为唯一最小的点。
该点同列的所有点中，该点为唯一最大的点。

让你输出∑(a=1~n)∑(b=1~m)a*b*S(a,b)

【类型】
贪心思维 单调思维

【分析】
这题用ST-RMQ的算法会导致tle
于是我们要尝试用O(nm)的算法AC这道题。
也就是说，用均摊O(1)的复杂度，求出——
1，每个点向左最多延伸多少个数，都比它大
2，每个点向右最多延伸多少个数，都比它大
3，每个点向上最多延伸多少个数，都比它小
4，每个点向下最多延伸多少个数，都比它小

这个的处理方式，可以是本程序的暴力跳。
比如我们处理，"每个点向左最多延伸多少个数，都比它大"时，
int p = j - 1;
while (p >= 1 && a[i][p] > a[i][j])p = lft[i][p] - 1;
lft[i][j] = p + 1;

我们对每个点，处理其向左可以延展的最大区间段。
如果发现再向左所延展的区间点，小于等于它，那延展失效。
否则便可以继续向左延展。
这个延展的过程，实际上也是区间合并。
显然我们一共只有n个区间，每次向左延展，也意味着多一次的区间合并。
而每个区间最多被合并一次，所以对于每行的m个数，处理lft[][]的总的复杂度为O(m)
即单点均摊复杂度为O(m)，总复杂度为O(nm)

当然，这个过程还可以通过单调栈实现。
以处理lft为例。
我们维护一个严格上升的单调栈。
对于每一个位点，
如果其之前栈顶元素大于它，那么该点的左延展区间范围，就可以覆盖到该栈顶元素，我们同时做出栈处理。
直到——使得其之前栈顶元素小于等于它，那么该点就无法向左延展了，其延展的极限也就知道了。

因为每个点最多入栈一次，出栈一次。所以每点的均摊复杂度为O(1)

=======================
当我们处理完每个点向左向右向上向下的最大延展范围后。
那这个点有贡献的矩阵，
向上的延展长度，可以是[1,top]
向下的延展长度，可以是[1,bot]
向左的延展长度，可以是[1,lft]
向右的延展长度，可以是[1,rgt]

也就是说，包括该点的

【时间复杂度&&优化】
O(nm)

【数据】
100 
5 5 
3 0 7 9 10 
4 9 9 9 7 
7 1 7 1 10 
3 1 8 6 1 
2 2 6 7 10 

*/
【HDU5749 BestCoder Round 84C】【ST-RMQ？NO！单调栈法 + 贡献思维】Colmerauer 所有子矩阵size乘鞍点权值和 

#include<stdio.h>
#include<iostream>
#include<string.h>
#include<string>
#include<ctype.h>
#include<math.h>
#include<set>
#include<map>
#include<vector>
#include<queue>
#include<bitset>
#include<algorithm>
#include<time.h>
using namespace std;
void fre() { freopen("c://test//input.in", "r", stdin); freopen("c://test//output.out", "w", stdout); }
#define MS(x,y) memset(x,y,sizeof(x))
#define MC(x,y) memcpy(x,y,sizeof(x))
#define MP(x,y) make_pair(x,y)
#define ls o<<1
#define rs o<<1|1
typedef long long LL;
typedef unsigned long long UL;
typedef unsigned int UI;
template <class T1, class T2>inline void gmax(T1 &a, T2 b) { if (b>a)a = b; }
template <class T1, class T2>inline void gmin(T1 &a, T2 b) { if (b<a)a = b; }
const int N = 1010, M = 0, Z = 1e9 + 7, ms63 = 0x3f3f3f3f;
int casenum, casei;
int n, m;
int a[N][N];
UI c[N + N];
UI d[N][N];
int lft[N][N];
int rgt[N][N];
int top[N][N];
int bot[N][N];

int sta[N], tp;
void RMQinit()
{
	for (int i = 1; i <= n; ++i)
	{
		sta[tp = 0] = 0; a[i][0] = -1e9;
		for (int j = 1; j <= m; ++j)
		{
			while (a[i][sta[tp]] > a[i][j])--tp;
			lft[i][j] = sta[tp] + 1;
			//if (a[i][sta[tp]] == a[i][j])--tp;
			sta[++tp] = j;
		}
	}
	for (int i = 1; i <= n; ++i)
	{
		sta[tp = 0] = m + 1; a[i][m + 1] = -1e9;
		for (int j = m; j >= 1; --j)
		{
			while (a[i][sta[tp]] > a[i][j])--tp;
			rgt[i][j] = sta[tp] - 1;
			//if (a[i][sta[tp]] == a[i][j])--tp;
			sta[++tp] = j;
		}
	}
	for (int j = 1; j <= m; ++j)
	{
		sta[tp = 0] = 0; a[0][j] = 1e9;
		for (int i = 1; i <= n; ++i)
		{
			while (a[sta[tp]][j] < a[i][j])--tp;
			top[i][j] = sta[tp] + 1;
			//if (a[sta[tp]][j] == a[i][j])--tp;
			sta[++tp] = i;
		}
	}
	for (int j = 1; j <= m; ++j)
	{
		sta[tp = 0] = n + 1; a[n + 1][j] = 1e9;
		for (int i = n; i >= 1; --i)
		{
			while (a[sta[tp]][j] < a[i][j])--tp;
			bot[i][j] = sta[tp] - 1;
			//if (a[sta[tp]][j] == a[i][j])--tp;
			sta[++tp] = i;
		}
	}
}

int main()
{
	for (int i = 1; i <= 2000; ++i)c[i] = c[i - 1] + i;
	for (int i = 1; i <= 1000; ++i)
	{
		for (int j = 1; j <= 1000; ++j)
		{
			//d[i][j] = d[i][j - 1] + c[i + j - 1] - c[j - 1];	//第一种计算方法
			d[i][j] = i*c[j] + j*c[i] - i*j;					//第二种计算方法
			
		}
	}
	scanf("%d", &casenum);
	for (casei = 1; casei <= casenum; ++casei)
	{
		scanf("%d%d", &n, &m);
		for (int i = 1; i <= n; ++i)
		{
			for (int j = 1; j <= m; ++j)
			{
				scanf("%d", &a[i][j]);
			}
		}
		RMQinit();
		UI ans = 0;
		for (int i = 1; i <= n; ++i)
		{
			for (int j = 1; j <= m; ++j)
			{
				int topp = top[i][j];
				int bott = bot[i][j];
				int lftt = lft[i][j];
				int rgtt = rgt[i][j];
				ans += d[i - topp + 1][bott - i + 1] * d[j - lftt + 1][rgtt - j + 1] * a[i][j];
			}
		}
		printf("%u\n", ans);
	}
	return 0;
}
/*
【trick&&吐槽】
复杂度，复杂度，复杂度！
复杂度包括——
思维复杂度
代码复杂度
时空复杂度。

这道题上来就想到求出每个点，作为鞍点，向左向右可以延展多少，向上向下可以延展多少。
不过是想用ST-RMQ实现。
而ST-RMQ的复杂度多了一个log(n)

妈蛋，zimpha的数据竟然不水了，多个log的算法就tle了。
>.<虽然节省了思维复杂度，却浪费了代码复杂度与时空复杂度，最后没有AC。
还是酌情想出高效的算法比较好。

【题意】
给你一个n*m的矩阵。
我们定义S(a,b)为所有大小为a*b的子矩阵的权值和。
一个子矩阵的权值和，定义为——
该矩阵中有所有鞍点的权值和。

一个矩阵中的鞍点，定义为——
该点同行的所有点中，该点为唯一最小的点。
该点同列的所有点中，该点为唯一最大的点。

让你输出∑(a=1~n)∑(b=1~m)a*b*S(a,b)

【类型】
贪心思维 单调思维

【分析】
这题用ST-RMQ的算法会导致tle
于是我们要尝试用O(nm)的算法AC这道题。
也就是说，用均摊O(1)的复杂度，求出——
1，每个点向左最多延伸多少个数，都比它大
2，每个点向右最多延伸多少个数，都比它大
3，每个点向上最多延伸多少个数，都比它小
4，每个点向下最多延伸多少个数，都比它小

这个的处理方式，可以是本程序的暴力跳。
比如我们处理，"每个点向左最多延伸多少个数，都比它大"时，
int p = j - 1;
while (p >= 1 && a[i][p] > a[i][j])p = lft[i][p] - 1;
lft[i][j] = p + 1;

我们对每个点，处理其向左可以延展的最大区间段。
如果发现再向左所延展的区间点，小于等于它，那延展失效。
否则便可以继续向左延展。
这个延展的过程，实际上也是区间合并。
显然我们一共只有n个区间，每次向左延展，也意味着多一次的区间合并。
而每个区间最多被合并一次，所以对于每行的m个数，处理lft[][]的总的复杂度为O(m)
即单点均摊复杂度为O(m)，总复杂度为O(nm)

当然，这个过程还可以通过单调栈实现。
以处理lft为例。
我们维护一个严格上升的单调栈。
对于每一个位点，
如果其之前栈顶元素大于它，那么该点的左延展区间范围，就可以覆盖到该栈顶元素，我们同时做出栈处理。
直到——使得其之前栈顶元素小于等于它，那么该点就无法向左延展了，其延展的极限也就知道了。

因为每个点最多入栈一次，出栈一次。所以每点的均摊复杂度为O(1)

=======================
当我们处理完每个点向左向右向上向下的最大延展范围后，我们要开始算贡献了——

对于每个点，这个点作为鞍点，那这个点所得到贡献的矩阵——
向上的延展长度，可以是[1,top]
向下的延展长度，可以是[1,bot]
向左的延展长度，可以是[1,lft]
向右的延展长度，可以是[1,rgt]
其贡献，也就是
int y=0, x=0;
for(int i=1;i<=top;++i)
{
	for(int j=1;j<=bot;++j)
	{
		y+=(i+j-1);
	}
}
for(int i=1;i<=lft;++i)
{
	for(int j=1;j<=rgt;++j)
	{
		x+=(i+j-1);
	}
}
ans+=y*x*a[i][j]

我们的做法有以下几种——
1，预处理for(int i=1;i<=a;++i)for(int j=1;j<=b;++j)tmp+=i+j-1;
这个的预处理，d[i][j]是在d[i][j-1]的基础上，获得了c[i+j-1]-c[j-1]的增长
2，独立(i)与(j)算贡献，显然——
	for(int i=1;i<=a;++i)for(int j=1;j<=b;++j)tmp+=i+j-1;
	有b个(1~a)，有a个(1~b)，再减去a*b个1

【时间复杂度&&优化】
O(nm)

【数据】
100
5 5
3 0 7 9 10
4 9 9 9 7
7 1 7 1 10
3 1 8 6 1
2 2 6 7 10

*/


snowy_smile
关注
  • 2
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
Hdu 5749 Colmerauer
_zidaoziyan的博客
07-24 454
题意: Peter有一个n×m的矩阵M.定义S(a,b)为M的所有大小为a×b的子矩阵的权值和.一个矩阵的权值是这个矩阵所有鞍点的值的和.在矩阵中,一个数在所在行中是唯一的最小值,在所在列中是唯一的最大值,则被称为鞍点.帮助Peter找出所有S(a,b)的值. 输出W=(∑a=1n∑b=1ma⋅b⋅S(a,b)) mod 232W = (\displaystyle\sum_{a=1}^{n}\s
C语言编程找鞍点
热门推荐
hhxy_wlzx的博客
12-16 2万+
在矩阵A中存在一点B（i，j），如果在B点那一行是最大值，且在B点那一列是最小值则B是鞍点。 输入格式: 输入的第1行是一个正整数n, （1&lt;=n&lt;=100），然后有n行，每一行有n个整数，同一行上两个整数之间有一个或多个空格。 输出格式： 对输入的矩阵，如果找到鞍点，就输出其下标。下标为两个数字，第一个数字是行号，第二个数字是列号，均从0开始计数。 如果找不到，就输出NO。 //求二...
HDU 5749 Colmerauer(单调栈或单调队列求解固定区间最大或最小值)
qq_18661257的专栏
07-26 1190
Colmerauer Time Limit: 10000/5000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others) Total Submission(s): 276    Accepted Submission(s): 118 Problem Description Peter has an n
hdu 5749 公式
touwangyi的博客
01-17 244
题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=5749 参考文章：http://m.blog.csdn.net/article/details?id=52020617 题目要求求出这个公式的值，首先来看S（a，b），其实对于一个矩阵，可以手动画一下，一个矩阵的鞍点至多只有一个，那么s（a,b）其实就是矩阵中这个鞍点的值，那么如何来求鞍点。
矩阵鞍点代码
图图
05-25 3313
一、什么是鞍点呢？在矩阵中，一个数在所在行中是最大值，在所在列中是最小值，则被称为鞍点。二、代码实现1、方法一：方法一： // Created by Neil Wesley on 16/5/25. // Copyright © 2016年 Neil Wesley. All rights reserved. //#include "stdio.h" int main() { int a[4
HDU.rar_hdoj 2000 2999 chm_hdoj 2000-2099_hdu_hdu acm 20_杭电ACM
09-22
这份名为"HDU.rar"的压缩包文件，包含了针对杭电（Hangzhou Dianzi University，简称HDU）ACM竞赛平台上的2000至2099号题目的一系列解题报告。这些报告以".chm"（Compiled Help Manual）格式存储，是专门为ACM（国际...
HDU-Experience:用于向所有杭电学子分享在杭电的知识与经验
04-30
项目简介：本项目意为向所有杭电学子提供各种信息，学习资料以及生活经验等。薪火相传，只为更好的杭电。总体结构：学习高等数学工程制图计算机图形学计算机系统结构计算机组成原理计算机网络考研离散数学马原密码学...
HDU+2000-2099+解题报告
08-31
HDU（杭州电子科技大学）在线评测系统是许多编程竞赛爱好者和学习者经常访问的平台，它提供了大量的算法题目供用户练习和挑战。这个压缩包文件“HDU 2000-2099 解题报告”显然包含了在这个题号范围内的一些问题、...
hdu-page-11-answer.rar_hdu_hdu oj第十一页_page_搜题_杭电oj
09-14
对于初学者来说，首先要了解基础数据结构，如数组、链表、栈、队列、树、图等，以及基本的搜索和排序算法，如二分查找、冒泡排序、快速排序等。这些知识是解决ACM问题的基础。 二、杭电OJ系统介绍 杭电OJ是在线进行...
HDU-2000-2099.rar_hdu
09-19
HDU（杭州电子科技大学在线评测系统）是一个知名的编程竞赛平台，为编程爱好者提供了大量的算法题目进行练习和比赛。这个名为"HDU-2000-2099.rar_hdu"的压缩包包含了该平台从2000到2099共100道题目的源代码。这些...
鞍点（saddle point）
linkequa的博客
03-25 1万+
1，在直角坐标系中，某个点是一个方向上的极大值，另一个方向上的极小值，则该点是鞍点。 对于二维平面，如y=x3y=x^3y=x3在x=0处，该点又称为驻点。 对于三维平面，如y=x2−y2y=x^2-y^2y=x2−y2在（0，0，0）处就是一个鞍点。 2，在微分方程中，沿着某一方向是稳定的，沿着另一方向不稳定的奇点，就叫鞍点；在泛函分析中，既不是极大值点也不是极小值低点的临界点就叫做鞍点；在矩阵...
HDU 5749 Colmerauer(单调栈、思维、组合)
ramay7
07-26 530
题目链接： HDU 5749 Colmerauer 题意： 给一个n∗mn*m的矩阵，定义长为aa宽为bb的矩阵的函数S(a,b)S(a,b)是矩阵中所有鞍点的权值和。一个矩阵的鞍点是所有满足在同一行中唯一最小，同一列中唯一最大的点。求: ∑i=1i=n∑j=1j=mi∗j∗S(i,j)(mod 232)\sum_{i=1}^{i=n}\sum_{j=1}^{j=m}i*j*S(i,j)\q
:计算鞍点
u011644858的博客
04-24 2014
5:计算鞍点 查看 提交 统计 提问 总时间限制: 1000ms 内存限制: 65536kB 描述 给定一个5*5的矩阵，每行只有一个最大值，每列只有一个最小值，寻找这个矩阵的鞍点。 鞍点指的是矩阵中的一个元素，它是所在行的最大值，并且是所在列的最小值。 例如：在下面的例子中（第4行第1列的元素就是鞍点，值为8 ）。 11 3 5 6 9 12 4 7 8 10 10 5 6 9...
【HDU5923 2016CCPC东北地区大学生程序设计竞赛 - 重现赛 B】【并查集 暴力 复杂度计算】Prediction 生效若干条链上的所有边条件下的联通块情况
snowy_smile的博客
10-08 1367
Prediction Time Limit: 5000/2500 MS (Java/Others)    Memory Limit: 65536/65536 K (Java/Others) Total Submission(s): 356    Accepted Submission(s): 63 Problem Description There is a graph G =\l
【ZOJ3940 The 13th Zhejiang Provincial Collegiate Programming ContestE】【脑洞 STL-MAP 复杂度分析 区间运算思想 双指针】M
snowy_smile的博客
04-26 1152
Modulo Query Time Limit: 2 Seconds      Memory Limit: 65536 KB One day, Peter came across a function which looks like: F(1, X) = X mod A1.F(i, X) = F(i - 1, X) mod Ai, 2 ≤ i ≤ N. Where
【ZOJ3951 The 17th Zhejiang University Programming Contest D】【树形DP 合并思想 复杂度计算】Independent Set 构造树使得不同
snowy_smile的博客
04-12 905
Independent Set Time Limit: 1 Second      Memory Limit: 65536 KB      Special Judge Chiaki has a positive integer m and she would like to construct a tree with at most 15 vertices in such a mann
【HDU5750 BestCoder Round 84D】【数学 贪心 复杂度计算】Dertouzos 范围有多少数的最大真约数为d
snowy_smile的博客
07-25 779
Dertouzos Accepts: 76 Submissions: 1357 Time Limit: 7000/3500 MS (Java/Others) Memory Limit: 131072/131072 K (Java/Others) 问题描述 正整数xxx称为nnn的positive proper divisor, 当且仅当x∣nx | nx∣n并且1≤
【“盛大游戏杯”第15届上海大学程序设计联赛 H】【水题预处理】调和序列
snowy_smile的博客
07-11 762
调和序列 发布时间: 2017年7月9日 18:17   最后更新: 2017年7月9日 21:05   时间限制: 1000ms   内存限制: 128M 描述 给定一个长度为n的非负整数序列，下标为0,1,…,n−1.  定义：sequence(K)： 由下标为K的倍数组成的子序列,即下标为0,K,2K,...,[n−1/k]∗k query(K,S):
hdu-1569(网络流)-最大点权独立集
最新发布
05-30
这是一道经典的网络流问题，可以使用最小割模型进行建模。 首先，将所有点拆成两个点，分别表示该点被选中和不被选中两种状态。对于每个点，如果它被选中，则将它的点权加入最终结果中。接下来，对于每条边 $(u,v)$，从 $u$ 的被选中状态向 $v$ 的不被选中状态连一条容量为 $\infty$ 的边。最后，从所有被选中状态的点向源点连一条容量为 $\infty$ 的边，从汇点向所有不被选中状态的点连一条容量为 $\infty$ 的边。 跑一遍最小割即可得到最大点权独立集。具体来说，最小割的值等于被选中的点的点权之和，而最小割对应的割就是最大点权独立集。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值