Repair the brckets FZU1987

最新推荐文章于 2019-04-03 08:44:37 发布
最新推荐文章于 2019-04-03 08:44:37 发布
阅读量679 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： 线段树&splay 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/gyarenas/article/details/9239365
本文介绍了一种利用伸展树（Splay Tree）解决括号序列修复问题的方法，包括替换、反转、翻转等操作，并提供了详细的算法实现过程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >


这道题的关键就是知道一个修复一个括号序列的最小改变数

把'('变成1，')'变成-1，lmi为左起最小连续子段和(可以为空)，sum为序列的和，则答案为(lim+1)/2+(sum-lmi+1)/2

简单想了想，设i为lmi的结束下标，则有[1, i]所有的'('全部被匹配，[i+1, n]全部的‘)’都被匹配，如果不满足这个性质的话，则lmi还可以更小，这与假设相矛盾，所以-lmi就是[1,i]中没有被匹配的')'个数，而sum-lmi就是[i+1, n]没有被匹配的'('个数,所以只要分别修改[1,i]中的')'和[i+1]中的'('即可，由于原序列长度为偶数，所以|lmi|+|sum-lmi|一定是偶数,但

|lmi|和|sum-lmi|不一定是偶数,对于这种情况需要吧[1,i]中最后一个未匹配')'变为'(',[i+1,n]第一个未匹配'('变为')'，而|lmi|-1和|sum-lmi|-1又变成了偶数，综合这两种情况就可以得到上面的式子

剩下的就是splay的各种鬼畜操作了

这种单纯考察数据结构的题我都要调试N多遍才能通过，看来代码能力还是需要加强额


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
#include <cctype>
#include <utility>   
#include <map>
#include <string>  
#include <climits> 
#include <set>
#include <string>    
#include <sstream>
#include <utility>   
#include <ctime>

using std::priority_queue;
using std::vector;
using std::swap;
using std::stack;
using std::sort;
using std::max;
using std::min;
using std::pair;
using std::map;
using std::string;
using std::cin;
using std::cout;
using std::set;
using std::queue;
using std::string;
using std::istringstream;
using std::make_pair;
using std::getline;
using std::greater;
using std::endl;
using std::multimap;
using std::deque;

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PAIR;
typedef multimap<int, int> MMAP;

const int MAXN(50010);
const int MAXM(10010);
const int MAXE(10010);
const int MAXH(19);
const int INFI((INT_MAX-1) >> 1);
const int MOD(10000);
const ULL BASE(31);
const LL LIM(10000000);
const int INV(-10000);


int arr[MAXN];

struct SPLAY_TREE
{
	struct NODE
	{
		int num, size, flag1, flag2, flag3;  //replace标记,reverse标记,inverse标记
		int sum, lmi, rmi, lmx, rmx;  //总和,左起连续最小和,右起连续最小和,左起连续最大和,右起连续最大和
		NODE *fa;
		NODE *ch[2];
	};

	NODE pool[MAXN];
	NODE *root, *NIL, *rear;
	inline void push_up(NODE *sour)  //一定要注意NIL节点对push_up的影响
	{
		sour->size = sour->ch[0]->size+sour->ch[1]->size+1;
		sour->sum = sour->ch[0]->sum+sour->ch[1]->sum+sour->num;
		sour->lmi = min(sour->ch[0]->lmi, sour->ch[0]->sum+sour->num+sour->ch[1]->lmi);
		sour->rmi = min(sour->ch[1]->rmi, sour->ch[1]->sum+sour->num+sour->ch[0]->rmi);
		sour->lmx = max(sour->ch[0]->lmx, sour->ch[0]->sum+sour->num+sour->ch[1]->lmx);
		sour->rmx = max(sour->ch[1]->rmx, sour->ch[1]->sum+sour->num+sour->ch[0]->rmx);
	}
	inline void updata_rep(NODE *sour, int v)
	{
		if(sour == NIL) return;
		sour->num = v;
		sour->sum = v*sour->size;
		sour->rmi = sour->lmi = v > 0? 0: v*sour->size;
		sour->lmx = sour->rmx = v > 0? v*sour->size: 0;
		sour->flag1 = v;
		sour->flag2 = 0;
		sour->flag3 = 0;
	}
	inline void updata_rev(NODE *sour)
	{
		if(sour == NIL) return;
		swap(sour->ch[0], sour->ch[1]);
		swap(sour->lmi, sour->rmi);
		swap(sour->lmx, sour->rmx);
		sour->flag2 ^= 1;
	}
	inline void updata_inv(NODE *sour)
	{
		if(sour == NIL) return;
		int temp = sour->lmi;
		swap(sour->lmi, sour->lmx);
		swap(sour->rmi, sour->rmx);
		sour->lmi *= -1;
		sour->lmx *= -1;
		sour->rmi *= -1;
		sour->rmx *= -1;
		sour->num *= -1;
		sour->sum *= -1;
		if(sour->flag1)
			sour->flag1 *= -1;
		else
			sour->flag3 ^= 1;
	}
	void push_down(NODE *sour)  //和线段树的push_down一样，是对子节(注意不是本节点)进行更新
	{
		if(sour->flag1)
		{
			updata_rep(sour->ch[0], sour->flag1);
			updata_rep(sour->ch[1], sour->flag1);
			sour->flag1 = 0;
		}
		if(sour->flag2)
		{
			updata_rev(sour->ch[0]);
			updata_rev(sour->ch[1]);
			sour->flag2 = 0;
		}
		if(sour->flag3)
		{
			updata_inv(sour->ch[0]);
			updata_inv(sour->ch[1]);
			sour->flag3 = 0;
		}
	}
	void initNIL()
	{
		NIL->ch[0] = NIL->ch[1] = NIL->fa = NIL;
		NIL->lmi = NIL->rmi = NIL->lmx = NIL->rmx = NIL->sum = NIL->num = 0;
		NIL->size = 0;
	}

	void init(int n)
	{
		NIL = pool;
		initNIL();
		rear = pool+1;
		newnode(root, NIL, -100000);  //插入无穷小
		newnode(root->ch[1], root, 100000); //插入无穷大
		build_tree(root->ch[1]->ch[0], root->ch[1], 1, n); //建树
		push_up(root->ch[1]);
		push_up(root);
	}

	void newnode(NODE *&sour, NODE *f, int num)
	{
		sour = rear++;
		sour->num = sour->sum = num;
		sour->size = 1;
		sour->lmi = sour->rmi = num > 0? 0: num;
		sour->lmx = sour->rmx = num > 0? num: 0;
		sour->flag1 = sour->flag2 = sour->flag3 = 0;
		sour->fa = f;
		sour->ch[0] = sour->ch[1] = NIL;
	}

	void build_tree(NODE *&sour, NODE *f, int l, int r)
	{
		if(l > r)
			return;
		int m = (l+r) >> 1;
		newnode(sour, f, arr[m]);
		build_tree(sour->ch[0], sour, l, m-1);
		build_tree(sour->ch[1], sour, m+1, r);
		push_up(sour);
	}

	void rotate(NODE *sour, int flag)
	{
		NODE *f = sour->fa;
		push_down(f);
		push_down(sour);
		f->ch[!flag] = sour->ch[flag];
		sour->ch[flag]->fa = f;
		sour->fa = f->fa;
		if(f->fa != NIL)
			f->fa->ch[f->fa->ch[1] == f] = sour;
		sour->ch[flag] = f;
		f->fa = sour;
		push_up(f);
	}
	
	void splay(NODE *sour, NODE *goal)
	{
		push_down(sour);
		while(sour->fa != goal)
		{
			if(sour->fa->fa == goal)
				rotate(sour, sour->fa->ch[0] == sour);
			else
			{
				NODE *f = sour->fa;
				int flag = (f->fa->ch[0] == f);
				if(f->ch[flag] == sour)
					rotate(sour, !flag);
				else
					rotate(f, flag);
				rotate(sour, flag);
			}
		}
		push_up(sour);
		if(goal == NIL)
			root = sour;
	}

	NODE *select(NODE *sour, int r)
	{
		while(sour != NIL)
		{
			push_down(sour);
			if(r == sour->ch[0]->size+1)
				break;
			if(r <= sour->ch[0]->size)
				sour = sour->ch[0];
			else
			{
				r -= sour->ch[0]->size+1;
				sour = sour->ch[1];
			}
		}
		return sour;
	}
	inline void pick(int pos1, int pos2)
	{
		NODE *tp = select(root, pos1);
		splay(tp, NIL);
		tp = select(root, pos2+2);
		splay(tp, root);
	}
	void REPLACE(int pos1, int pos2, int value)
	{
		pick(pos1, pos2);
		updata_rep(root->ch[1]->ch[0], value);
		push_up(root->ch[1]);
		push_up(root);
	}

	void SWAP(int pos1, int pos2)
	{
		pick(pos1, pos2);
		updata_rev(root->ch[1]->ch[0]);
		push_up(root->ch[1]);
		push_up(root);
	}

	void INVERT(int pos1, int pos2)
	{
		pick(pos1, pos2);
		updata_inv(root->ch[1]->ch[0]);
		push_up(root->ch[1]);
		push_up(root);
	}

	int QUERY(int pos1, int pos2)
	{
		pick(pos1, pos2);
		NODE *tp = root->ch[1]->ch[0];
		return (abs(tp->sum-tp->lmi)+1)/2+(abs(tp->lmi)+1)/2;
	}
};

SPLAY_TREE spt;
char str[10];
int op1, op2;
char op3;

int main()
{
	int TC, n_case(0);
	scanf("%d", &TC);
	while(TC--)
	{
		int n, m;
		scanf("%d%d", &n, &m);
		char temp;
		for(int i = 1; i <= n; ++i)
		{
			scanf(" %c", &temp);
			arr[i] = temp == '('? 1: -1;
		}
		spt.init(n);
		printf("Case %d:\n", ++n_case);
		for(int i = 0; i < m; ++i)
		{
			scanf("%s", str);
			if(str[0] == 'R')
			{
				scanf("%d%d %c", &op1, &op2, &op3);
				spt.REPLACE(op1, op2, op3 == '('? 1: -1);
			}
			else if(str[0] == 'S')
			{
				scanf("%d%d", &op1, &op2);
				spt.SWAP(op1, op2);
			}
			else if(str[0] == 'I')
			{
				scanf("%d%d", &op1, &op2);
				spt.INVERT(op1, op2);
			}
			else
			{
				scanf("%d%d", &op1, &op2);
				printf("%d\n", spt.QUERY(op1, op2));
			}
		}
	}
	return 0;
}

又想了想，lmx和rmx是不必要维护的 


#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <queue>
#include <algorithm>
#include <vector>
#include <cstring>
#include <stack>
#include <cctype>
#include <utility>   
#include <map>
#include <string>  
#include <climits> 
#include <set>
#include <string>    
#include <sstream>
#include <utility>   
#include <ctime>

using std::priority_queue;
using std::vector;
using std::swap;
using std::stack;
using std::sort;
using std::max;
using std::min;
using std::pair;
using std::map;
using std::string;
using std::cin;
using std::cout;
using std::set;
using std::queue;
using std::string;
using std::istringstream;
using std::make_pair;
using std::getline;
using std::greater;
using std::endl;
using std::multimap;
using std::deque;

typedef long long LL;
typedef unsigned long long ULL;
typedef pair<int, int> PAIR;
typedef multimap<int, int> MMAP;

const int MAXN(50010);
const int MAXM(10010);
const int MAXE(10010);
const int MAXH(19);
const int INFI((INT_MAX-1) >> 1);
const int MOD(10000);
const ULL BASE(31);
const LL LIM(10000000);
const int INV(-10000);


int arr[MAXN];

struct SPLAY_TREE
{
	struct NODE
	{
		int num, size, flag1, flag2, flag3;  
		int sum, lmi, rmi;                   //区域和 ,左起连续最小和(可以0个元素), 右起连续最小和(可以0个元素)
		NODE *fa;
		NODE *ch[2];
	};

	NODE pool[MAXN];
	NODE *root, *NIL, *rear;
	inline void push_up(NODE *sour)  //一定要注意NIL节点对push_up的影响
	{
		sour->size = sour->ch[0]->size+sour->ch[1]->size+1;
		sour->sum = sour->ch[0]->sum+sour->ch[1]->sum+sour->num;
		sour->lmi = min(sour->ch[0]->lmi, sour->ch[0]->sum+sour->num+sour->ch[1]->lmi);
		sour->rmi = min(sour->ch[1]->rmi, sour->ch[1]->sum+sour->num+sour->ch[0]->rmi);
	}
	inline void updata_rep(NODE *sour, int v)
	{
		if(sour == NIL) return;
		sour->num = v;
		sour->sum = v*sour->size;
		sour->rmi = sour->lmi = v > 0? 0: v*sour->size;
		sour->flag1 = v;
		sour->flag2 = 0;
		sour->flag3 = 0;
	}
	inline void updata_rev(NODE *sour)
	{
		if(sour == NIL) return;
		swap(sour->ch[0], sour->ch[1]);
		swap(sour->lmi, sour->rmi);
		sour->flag2 ^= 1;
	}
	inline void updata_inv(NODE *sour)
	{
		if(sour == NIL) return;
		int temp = sour->lmi;
		sour->lmi = -(sour->sum-sour->rmi);
		sour->rmi = -(sour->sum-temp);
		sour->sum *= -1;
		sour->num *= -1;
		if(sour->flag1)
			sour->flag1 *= -1;
		else
			sour->flag3 ^= 1;
	}
	void push_down(NODE *sour)  //和线段树的push_down一样，是对子节(注意不是本节点)进行更新
	{
		if(sour->flag1)
		{
			updata_rep(sour->ch[0], sour->flag1);
			updata_rep(sour->ch[1], sour->flag1);
			sour->flag1 = 0;
		}
		if(sour->flag2)
		{
			updata_rev(sour->ch[0]);
			updata_rev(sour->ch[1]);
			sour->flag2 = 0;
		}
		if(sour->flag3)
		{
			updata_inv(sour->ch[0]);
			updata_inv(sour->ch[1]);
			sour->flag3 = 0;
		}
	}
	void initNIL()
	{
		NIL->ch[0] = NIL->ch[1] = NIL->fa = NIL;
		NIL->lmi = NIL->rmi = NIL->sum = NIL->num = 0; 
		NIL->size = 0;
	}

	void init(int n)
	{
		NIL = pool;
		initNIL();
		rear = pool+1;
		newnode(root, NIL, -100000);  //插入无穷小
		newnode(root->ch[1], root, 100000); //插入无穷大
		build_tree(root->ch[1]->ch[0], root->ch[1], 1, n); //建树
		push_up(root->ch[1]);
		push_up(root);
	}

	void newnode(NODE *&sour, NODE *f, int num)
	{
		sour = rear++;
		sour->num = sour->sum = num;
		sour->size = 1;
		sour->lmi = sour->rmi = num > 0? 0: num;
		sour->flag1 = sour->flag2 = sour->flag3 = 0;
		sour->fa = f;
		sour->ch[0] = sour->ch[1] = NIL;
	}

	void build_tree(NODE *&sour, NODE *f, int l, int r)
	{
		if(l > r)
			return;
		int m = (l+r) >> 1;
		newnode(sour, f, arr[m]);
		build_tree(sour->ch[0], sour, l, m-1);
		build_tree(sour->ch[1], sour, m+1, r);
		push_up(sour);
	}

	void rotate(NODE *sour, int flag)
	{
		NODE *f = sour->fa;
		push_down(f);
		push_down(sour);
		f->ch[!flag] = sour->ch[flag];
		sour->ch[flag]->fa = f;
		sour->fa = f->fa;
		if(f->fa != NIL)
			f->fa->ch[f->fa->ch[1] == f] = sour;
		sour->ch[flag] = f;
		f->fa = sour;
		push_up(f);
	}
	
	void splay(NODE *sour, NODE *goal)
	{
		push_down(sour);
		while(sour->fa != goal)
		{
			if(sour->fa->fa == goal)
				rotate(sour, sour->fa->ch[0] == sour);
			else
			{
				NODE *f = sour->fa;
				int flag = (f->fa->ch[0] == f);
				if(f->ch[flag] == sour)
					rotate(sour, !flag);
				else
					rotate(f, flag);
				rotate(sour, flag);
			}
		}
		push_up(sour);
		if(goal == NIL)
			root = sour;
	}

	NODE *select(NODE *sour, int r)
	{
		while(sour != NIL)
		{
			push_down(sour);
			if(r == sour->ch[0]->size+1)
				break;
			if(r <= sour->ch[0]->size)
				sour = sour->ch[0];
			else
			{
				r -= sour->ch[0]->size+1;
				sour = sour->ch[1];
			}
		}
		return sour;
	}
	inline void pick(int pos1, int pos2)
	{
		NODE *tp = select(root, pos1);
		splay(tp, NIL);
		tp = select(root, pos2+2);
		splay(tp, root);
	}
	void REPLACE(int pos1, int pos2, int value)
	{
		pick(pos1, pos2);
		updata_rep(root->ch[1]->ch[0], value);
		push_up(root->ch[1]);
		push_up(root);
	}

	void SWAP(int pos1, int pos2)
	{
		pick(pos1, pos2);
		updata_rev(root->ch[1]->ch[0]);
		push_up(root->ch[1]);
		push_up(root);
	}

	void INVERT(int pos1, int pos2)
	{
		pick(pos1, pos2);
		updata_inv(root->ch[1]->ch[0]);
		push_up(root->ch[1]);
		push_up(root);
	}

	int QUERY(int pos1, int pos2)
	{
		pick(pos1, pos2);
		NODE *tp = root->ch[1]->ch[0];
		return (abs(tp->sum-tp->lmi)+1)/2+(abs(tp->lmi)+1)/2;
	}
};

SPLAY_TREE spt;
char str[10];
int op1, op2;
char op3;

int main()
{
	int TC, n_case(0);
	scanf("%d", &TC);
	while(TC--)
	{
		int n, m;
		scanf("%d%d", &n, &m);
		char temp;
		for(int i = 1; i <= n; ++i)
		{
			scanf(" %c", &temp);
			arr[i] = temp == '('? 1: -1;
		}
		spt.init(n);
		printf("Case %d:\n", ++n_case);
		for(int i = 0; i < m; ++i)
		{
			scanf("%s", str);
			if(str[0] == 'R')
			{
				scanf("%d%d %c", &op1, &op2, &op3);
				spt.REPLACE(op1, op2, op3 == '('? 1: -1);
			}
			else if(str[0] == 'S')
			{
				scanf("%d%d", &op1, &op2);
				spt.SWAP(op1, op2);
			}
			else if(str[0] == 'I')
			{
				scanf("%d%d", &op1, &op2);
				spt.INVERT(op1, op2);
			}
			else
			{
				scanf("%d%d", &op1, &op2);
				printf("%d\n", spt.QUERY(op1, op2));
			}
		}
	}
	return 0;
}




FZU 1978 Repair the brackets
Occult
02-23 556
Description A regular bracket sequence is defined as follows: 1. Empty sequence is a regular bracket sequence.2. If S is a regular bracket sequence, then (S) is also a regular bracket sequence.3
fzu 2216 The Longest Straight
老焦的博客
04-24 733
Problem 2216 The Longest Straight Accept: 178    Submit: 536 Time Limit: 1000 mSec    Memory Limit : 32768 KB  ProblemDescription ZB is playing a card game where the goal is to makestraights. Each
FZU 2216 The Longest Straight (二分)
Tc的专栏
08-20 651
FZU 2216 The Longest Straight (二分)
The Bigger the Better FZU - 2267
相似的人适合一起打闹
04-25 496
Fat brother and Maze are playing a kind of special (hentai) game with two integers. All the digits of these two integers are in the range from 1 to 9. After they’ve got these two integers, they thoug...
FZU2267 The Bigger the Better(模拟 memcmp函数)
UncleJokerly
04-26 542
Fat brother and Maze are playing a kind of special (hentai) game with two integers. All the digits of these two integers are in the range from 1 to 9. After they’ve got these two integers, they though...
The Longest Straight FZU - 2216
Sirius_han的博客
04-15 192
E - The Longest Straight 题目链接：FZU - 2216#include &lt;iostream&gt; #include &lt;algorithm&gt; #include &lt;string.h&gt; #i...
FZU 1704 Turn off the light
qianlv_的专栏
02-05 574
高斯消元 套模板， 求出方程的自由变量个数，由于变量取值只有0,1； 故2^(var-k)种方法，var-k最大取100，用高精 #include #include #include #include #include #include using namespace std; #define CL(a,b) memset(a,b,sizeof(a)) #define INF 1
犯罪嫌疑人 FZU - 2202
sunyutian1998的博客
04-03 214
http://acm.fzu.edu.cn/problem.php?pid=2202 记录下正负数各有多少 再用book[i]代表说i是或不是罪犯的个数 枚举罪犯 如果当i为罪犯时book1[i]+cnt2-book2[i]即为说真话的人数 如果该值等于m 则i有可能是罪犯 否则绝对是清白的 #include <cstdio> #include <cstring&...
FZU2230
ZP_nanfangguniang的博客
08-18 700
Problem 2230 翻翻棋 Accept: 217    Submit: 453 Time Limit: 1000 mSec    Memory Limit : 32768 KB  Problem Description 象棋翻翻棋（暗棋）中双方在4*8的格子中交战，有时候最后会只剩下帅和将。根据暗棋的规则，棋子只能上下左右移动，且相同的级别下，主动移动到地方棋子方将
FZU飞跃手册 相关文件 (FZU Flying Book Relevant documents)
最新发布
10-19
这是关于我们飞跃手册项目的相关文档，包括成员分组信息表格，各组成员任务概要文档，项目日记等文档。 (This is a collection of documents relating to our Leapfrog Handbook project, including member ...
C#作业（FZU）miniword完整版
11-20
【C# miniword 完整版】是一款基于C#编程语言开发的小型文字处理软件，类似于微软的Word，主要用于FZU（福州大学）的教学与作业。该项目旨在让学生熟悉C#编程环境，掌握Windows Forms应用程序的开发技术，以及对文本...
FZU编译原理实践作业一参考代码
04-09
仅作参考，抄被发现后果自负哈。
FZU软件工程web课程复习资料-整理
02-06
"FZU软件工程web课程复习资料-整理" 本资源是FZU软件工程web课程的复习资料，涵盖了web开发的基础知识和技术。下面是对该资源中所涉及的知识点的详细解释： 第一讲 web 开发概述 1. 因特网与万维网 因特网是一种...
FZU软件工程操作系统课程复习资料-整理
02-06
FZU软件工程操作系统课程复习资料-整理 本资源摘要信息是关于FZU软件工程操作系统课程复习资料的整理，涵盖操作系统的基本概念、进程和线程、存储管理和文件系统等方面的知识点。 一、操作系统的定义和主要功能 ...
关于维护AC自动机fail树的三道题目
霁月难逢 彩云易散
01-06 2790
由易到难 e-Government CF 163E http://blog.youkuaiyun.com/gyarenas/article/details/9315319 GRE Words hdu 4117  http://acm.hdu.edu.cn/showproblem.php?pid=4117 这题本来的做法是ac自动机优化dp，然而hdu加入了新的数据，估计构造了一些
带修改的区间第k大
霁月难逢 彩云易散
04-18 2693
http://acm.zju.edu.cn/onlinejudge/showProblem.do?problemId=1112 提高代码能力。。。 方法一： 线段树套平衡树，时间：O(m*lgn*lgn*lgn)，空间：O(n*lgn)。 #include #include #include #include #include using namespace std; c
阿狸的打字机 NOI2011
霁月难逢 彩云易散
07-06 2663
AC自动机是肯定的了，但关键是如何完成快速匹配，如果像普通的自动机那样在每个状态都通过fail转移累加的话肯定会超时的，所以需要一种新的方法，那就是维护fail逆向指针树的dfs序列，听上去挺麻烦的，先把所有fail指针逆向，这样就得到了一棵树(因为每个节点的出度都为1，所以逆向后每个节点入度为1，所以得到的是一棵树)，而一棵树的先序dsf序列有一个很好的性质就是同任一棵子树的节点是连续排列的(前
关于B-K tree与k-d tree一些自己想法
霁月难逢 彩云易散
05-10 2469
以前用B-K tree做过一个题，最近学习k-d tree，感觉这两个树有某些相似，这个俩种树都是寻找距目标点临近最近的点(B-K tree针对给定距离k以内，k-d tree针对给定最近的k个点)。 其中B-K tree只要求数据点之间定义可度量的距离，支持求距给定点距离k以内的数据点。相对于暴力法来说，是常数级别的提高，但有时会很有效（比如数据点之间距离范围很大，但阀值k很小），一个应用就是
郑厂长系列故事——新闻净化 hdu4534
霁月难逢 彩云易散
06-02 2235
AC自动机+DP， 此题有俩个优化目标：最少字母使文章符合要求，并让加成分之和尽可能高，可以把俩个目标合并成一个，即让删除一个字母所获得的加分为一个很小的值(此题可以取-200000)，这样优化的目标即变为是的加分最大，最后再把结果分离即可。 #include #include #include #include #include #include #include #in
我的fzu online judge解题思路分享
标题 "fzu online judge" 揭示了该文件内容涉及到的平台是福州大学在线评测系统，这是一个为编程爱好者、学生和专业人士提供的在线编程和算法竞赛平台。在这样的平台上，用户可以提交代码来解决一系列的编程问题，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值