离散化+各种神奇科技

最新推荐文章于 2024-03-03 21:32:59 发布
最新推荐文章于 2024-03-03 21:32:59 发布
阅读量195 收藏
点赞数
分类专栏： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45916935/article/details/108290139
版权

2020.9.08 更新 ： 添加科技尺取法
2020.9.09 更新 ： 添加科技折半枚举 顺便更新下二的代码

主要讲讲我这个蒟蒻的离散化做法（只讲大数据化小数据）

首先拷贝一份数据进r数组

接着对r数组排序，手动去重塞进num数组里边

用的时候二分就好了

code:

/*
给定一个长度为n的序列和m个询问xm，对于每个询问xi输出xi在序列内的排名
（如果xi没有出现过则输出-1）
*/
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
const int N = 100010;
int a[N] , r[N] , num[N] , len;
int n , m;

int find(int x)
{
	int l = 1 , r = len , mid , best = -1;
	while(l <= r)
	{
		mid = (l + r) >> 1;
		if(num[mid] >= x)
		{
			best = mid;
			r = mid - 1;
		}
		else l = mid + 1;
	}
	if(num[best] == x) return best;
	else return -1;
}

int main()
{
	cin >> n;
	for(int i = 1 ; i <= n ; i++)
	{
		cin >> a[i];
		r[i] = a[i];
	}
	sort(r + 1 , r + n + 1);
	for(int i = 1 ; i <= n ;)
	{
		int j = i + 1;
		while(r[i] == r[j] && j <= n) j++;
		num[++len] = r[i] ; i = j;
	}
	cin >> m;
	for(int i = 1 , x ; i <= m ; i++)
	{
		cin >> x;
		cout << find(x) << endl;
	}
	return 0;
}

结合几道题用一用

一.dp

很明显的状态机转移dp，主要是法术类型ki跟xi范围有点大，于是我们对它们一块进行离散化

温馨提示：xi不一定是k数组里边的数

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

typedef long long ll;
const int N = 500100 , M = 510;
//const ll inf = 1e7 + 1;
int n , m , x[N] , K[N] , len;
ll dp[3][M][3] , sum[N] , ans , rank[N] , P[N] , Maxn;
int num[N] , r[N];

inline int read()
{
	char c ; int res = 0;
	while(c < '0' || c > '9') c= getchar();
	while(c >= '0' && c <= '9')
	{
		res = res * 10 + c - '0';
		c = getchar();
	}
	return res;
}

inline void work()
{
	for(int i = 1 , j ; i <= n ;)
	{
		j = i + 1;
		while(r[j] == r[i] && j <= n) j++;
		num[++len] = r[i];
		i = j;
	}
}
inline int find(int x1)
{
	int l = 1 , r = len , mid , best = r;
	while(l <= r)
	{
		mid = (l + r) >> 1;
		if(num[mid] <= x1)
		{
			best = mid;
			l = mid + 1;
		}
		else r = mid - 1;
	}
	if(x1 == num[best]) return best;
	else return 0;
}

int main()
{
	n = read() ; m = read();
	memset(dp , -0x3f3f3f3f3f , sizeof dp);
	dp[0][0][0] = dp[0][1][0] = 0;
	for(int i = 1 ; i <= n ; i++)
	{
		K[i] = read();
		P[i] = read();
		r[i] = K[i];
	}
	for(int i = 1 ; i <= n ; i++)
		x[i] = read();
	sort(r + 1 , r + n + 1);
	work();
	for(int i = 1 ; i <= n ; i++)
	{
		Maxn = max(Maxn , P[i]);
		sum[find(K[i])] += P[i];
		int X = find(x[i]);
		dp[i & 1][0][0] = max(dp[(i + 1) & 1][0][0] + Maxn , dp[(i + 1) & 1][0][0] + sum[X]);//转移一 
		for(int k = 1 ; k <= m ; k++)
		{
			dp[(i & 1)][k][0] = max(dp[((i + 1) & 1)][k][1] + 2 * sum[X] , dp[((i + 1) & 1)][k][0] + sum[X]);//转移一 
			dp[(i & 1)][k][0] = max(dp[(i & 1)][k][0] , max(dp[((i + 1) & 1)][k][1] + 2 * Maxn , dp[((i + 1) & 1)][k][0] + Maxn));//转移二 
			dp[(i & 1)][k][1] = dp[((i + 1) & 1)][k - 1][0];//转移三  
		}//用了k次翻倍后 
	}
	printf("%lld" , dp[n & 1][m][0]);//这里有点玄学了
	//应该搜一遍dp[n & 1][1 到 m][0]跟dp[n & 1][1到 m][1]再取最大值的
	return 0;
}

实测504ms（优化全开），目前最优解第10名

二.并查集

单独处理xi == xj，再单独判断不相等的即可

还是注意离散化：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 1000010;
struct nod
{
    int x , y , w;
} a[N];
int n , T;
int num[N] , len;
int p[N];

bool cmp(nod a , nod b)
{
    return a.w < b.w;
}
int Find(int x)
{
    return p[x] == x ? x : p[x] = Find(p[x]);
}
int find(int x)
{
    int l = 1 , r = len , mid , best;
    while(l <= r)
    {
        mid = (l + r) >> 1;
        if(num[mid] >= x)
        {
            best = mid;
            r = mid - 1;
        }
        else l = mid + 1;
    }
    return best;
}
bool check(int i)
{
    for(; i <= n ; i++)
        if(Find(a[i].x) == Find(a[i].y)) return false;
    return true;
}
int main()
{
    scanf("%d" , &T);
    while(T--)
    {
        len = 0;
        scanf("%d" , &n);
        for(int i = 1 ; i <= n ; i++)
        {
            scanf("%d%d%d" , &a[i].x , &a[i].y , &a[i].w);
            num[++len] = a[i].x , num[++len] = a[i].y;
            if(a[i].w == 0) a[i].w = 2;
        }
        sort(a + 1 , a + n + 1 , cmp);
        sort(num + 1 , num + 2 * n + 1);
        len = 0;
        for(int i = 1 , j ; i <= 2 * n ;)
        {
            j = i + 1;
            while(num[i] == num[j] && j <= 2 * n) j++;
            num[++len] = num[i];
            i = j;
        }
        for(int i = 1 ; i <= len ; i++) p[i] = i;
        for(int i = 1 ; i <= n ; i++) a[i].x = find(a[i].x) , a[i].y = find(a[i].y);
        int i = 1;
        for( ; a[i].w == 1; i++)
        {
            int x = Find(a[i].x) , y = Find(a[i].y);
            if(p[x] == p[y]) continue;
            else p[x] = p[y];
        }
        if(check(i)) printf("YES\n");
        else printf("NO\n");
    }
    return 0;
}

三.尺取法

大意为求最小区间长度使得所有类型的元素均包含在内

按上面做法离散化类型，那总共类型个数即len

all数组储存某种元素的个数，变量now储存当前不同元素的个数

结合尺取法，若now < len 则向右拓展区间，并检查all，如果为空则now++，对应all++

若now == len 则检查左边界all，使其-1后若为0，则now–，左边界右移

code:

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
const int N = 1000010;
int n;
int num[N] , len;//离散数组
int P[N] , c[N] , all[N] , ans;
int now;
int find(int x)
{
	int l = 1 , r = len , mid , best;
	while(l <= r)
	{
		mid = (l + r) >> 1;
		if(num[mid] >= x)
		{
			best = mid;
			r = mid - 1;
		}
		else l = mid + 1;
	}
	return best;
}

int main()
{
	scanf("%d" , &n);
	for(int i = 1 ; i <= n ; i++)
	{
		scanf("%d" , &P[i]);
		num[i] = P[i];
	}
	sort(num + 1 , num + n + 1);
	for(int i = 1 , j ; i <= n ;)
	{
		j = i + 1;
		while(num[i] == num[j] && j <= n) j++;
		num[++len] = num[i];
		i = j;
	}//后来我发现num跟r可以合一块写...
	ans = n;
	int l = 1 , r = 1;
	now = 1;
	all[find(P[1])]++;
	while(l <= n && r <= n)
	{
		if(now != len)
		{
			r++ ;
			if(!all[find(P[r])]) now++;
			all[find(P[r])]++;
		}
		else
		{
			ans = min(ans , r - l + 1);
			all[find(P[l])]--;
			if(!all[find(P[l])]) now--;
			l++;
		}
	}
	printf("%d" , ans);
	return 0;
}

四.折半枚举

我们可以对数列一，二里的元素两两求和存到x数组里，数列三，四里的元素同理处理后存到y数组里

接下来对数组x和y离散化，同时将相同元素个数合并到离散化后的元素里，最后枚举x数组，在y数组里二分找到枚举值的相反数，利用乘法原理统计答案即可

算法复杂度为O(n²logn)，可以接受（但不知道为啥洛谷那边T飞了）

code:

#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N = 5001 , M = 5001 * 5001;
struct nod
{
	int data , num;
} x[M] , y[M];
int n;
int a[N][5] , t , len1 , len2;
bool cmp(nod a , nod b)
{
	return a.data < b.data;
}
int find(int x)
{
	int l = 1 , r = len2 , mid , best = len2;
	while(l <= r)
	{
		mid = (l + r) >> 1;
		if(y[mid].data >= x)
		{
			best = mid;
			r = mid - 1;
		}
		else l = mid + 1;
	}
	if(y[best].data == x) return y[best].num;
	else return -1;
}
int main()
{
	scanf("%d" , &n);
	for(int i = 1 ; i <= n ; i++)
		for(int j = 1 ; j <= 4 ; j++)
			scanf("%d" , &a[i][j]);
	t = n * n;
	for(int i = 1 ; i <= n ; i++)
		for(int j = 1 ; j <= n ; j++)
			x[(i - 1) * n + j].data = a[i][1] + a[j][2] ,
			y[(i - 1) * n + j].data = a[i][3] + a[j][4] ;
	sort(x + 1 , x + t + 1 , cmp);
	sort(y + 1 , y + t + 1 , cmp);
	len1 = 0 , len2 = 0;
	for(int i = 1 , j ; i <= t ;)
	{
		j = i + 1;
		while(x[i].data == x[j].data && j <= t) j++;
		x[++len1].data = x[i].data;
		x[len1].num = j - i;
		i = j;
	}
	for(int i = 1 , j ; i <= t ; )
	{
		j = i + 1;
		while(y[i].data == y[j].data && j <= t) j++;
		y[++len2].data = y[i].data;
		y[len2].num = j - i;
		i = j;
	}
	int ans = 0;
	for(int i = 1 ; i <= len1 ; i++)
	{
		int k = find(-x[i].data);
		if(k > 0)
			ans += x[i].num * k;
	}
	printf("%d" , ans);
	return 0;
}
Mongo_w
关注
专栏目录
智能浪潮：增强时代来临
GitChat
04-12 1万+
内容介绍 继互联网和智能手机出现之后，人工智能、基因工程、纳米制造、无人驾驶、机器人、可穿戴设备等各类技术风起云涌。我们的生活和工作，我们的交互和行为方式已经发生了彻底的改变： 语音可以控制家电； 网站会按照用户喜好推送内容； 运动手环记录下了身体数据，每日反馈健康报告； 机器人替代人工，准确无误分拣包裹； 无人机可以配送快递…… 作者布雷特·金认为我们已经踏入一个崭新的历史阶段的大门，走向...
前端实习日记——高新兴科技集团
weixin_30888027的博客
07-19 2251
7月16日（实习的第一天） 看公司前端的代码规范；了解AngularJS；了解Less；看项目代码。 项目“明镜”介绍：一两年前就开始做了，是做公安机关的生意，需求是实现公安执法办案的精细化、信息化。其中的前端部分要兼容IE8，所以要用AngularJS（1.2）。 7月17日 学菜鸟教程上的AngularJS教程；了解RequireJS；听上级讲解项目代码；看项目代码；了解Ng...
离散化
三季人的博客
05-20 430
离散化，简单来说就是将一些分散不集中的点经过映射，让这些点不改变原来顺序，让其集中起来。 举个例子： 离散化的操作：排序->去重 //s储存的是需要离散的值 sort(s.begin(), s.end()); s.erase(unique(s.begin(), s.end()), s.end()) 对于离散化的用途：再举一个非常极端的例子，假设有1000个数，分布在[0, 10 ^ 9],我要对区间[l, r]询问区间和，你被要求用前缀和做，那你难道要开一个10 ^ 9的数组吗，这显然是行不
离散化：两种离散化
weixin_64393298的博客
03-18 673
介绍： 离散化，就是把一些很离散的点给重新分配。 在一些问题中，我们只关心 n 个数字之间的相对大小关系，而不关心它 们具体是多少。 因此，我们可以用一种叫离散化的技术来将数字映射到 1 ∼ n 的整数， 从而降低问题规模，简化运算。 通常的实现方法是将所有数字排序，然后再重新遍历一遍所有的数字， 通过二分查找找到它们的 “排名”，然后用排名来代替对应的数字。 举个例子，如果一个坐标轴很长(>1e10)，给你1e4个坐标，询问某一个点，坐标比它小的点有多少。 很容易就知道，对于1e4个点，我们不
离散化(Discretization Algorithm)
BadBadBad的博客
03-03 1064
离散化(Discretization Algorithm)
【算法基础——第八讲】离散化
m0_63233163的博客
05-05 3829
大家好，我是quicklysleep，欢迎大家光临我的博客,算法学习笔记系列持续更新中~ 文章目录一、前言二、排序算法的介绍三、排序算法的运用1.快速排序模板2.冒泡排序模板3.归并排序模板最后 一、前言 排序算法是最基本的算法之一。 二、排序算法的介绍 排序算法可以分为内部排序和外部排序，内部排序是数据记录在内存中进行排序，而外部排序是因排序的数据很大，一次不能容纳全部的排序记录，在排序过程中需要访问外存。常见的内部排序算法有：插入排序、希尔排序、选择排序、冒泡排序、归并排序、快速排序、堆排.
离散化：两种离散化方式详解
热门推荐
曹老师
08-26 4万+
引入 离散化，就是把一些很离散的点给重新分配。 举个例子，如果一个坐标轴很长(&amp;gt;1e10)，给你1e4个坐标，询问某一个点，坐标比它小的点有多少。 很容易就知道，对于1e4个点，我们不必把他们在坐标轴上的位置都表示出来，因为我们比较有多少比它小的话，只需要知道他们之间的相对大小就可以，而不是绝对大小，这，就需要离散化。 而离散化又分为两种，分为的两种是对于重复元素来划分的。第一种是重...
探索计算机图形学：探秘神奇的3D显示技术
计算机图形学的主要作用是通过计算机生成并展示各种图形、图像和动画，以满足人们的视觉需求。 ## 1.2 3D显示技术的重要性和应用领域 随着科技的不断发展，三维（3D）显示技术在各个领域中变得越来越重要。它可以以...
电子科技大学量子力学课件
03-28
总的来说，《电子科技大学量子力学课件》通过01至06的章节，全面地涵盖了量子力学的基础理论，并逐步引导学习者理解这个充满神奇的量子世界。无论你是物理学的学生还是对量子科技感兴趣的公众，这份资源都将是你探索...
语音识别技术的前世今生【前世篇】
Nieson2012的专栏
07-22 5341
目录 1.背景 2.孤立词识别 2.1 特征提取 2.2 动态弯算法 2.3 GMM(Gaussian mixture model) 2.4 HMM(Hidden markov model) 2.5 EM训练算法 2.6 语音识别基本方程 3.连续语音识别 3.1 语言模型 3.2 大词汇量 3.3 语音识别系统结构 3.4 评价指标：WER 4. 潘多拉魔盒 4.1...
特征离散化系列(一)方法综述
微积分的博客
10-07 1万+
对现存的离散化方法进行概述总结，对现有离散化方法进行归类的层次化结构描述(hierarchical framework)，为进一步发展铺路(pave the way)，对典型的离散化方法(representative discretization methods)的简要讨论，大量的试验和分析，在不同的应用环境下选择离散化方法的原则.
[常用技巧] 数据离散化入门介绍
童凌的技术博客
07-20 6395
离散化是程序设计中一个非常常用的技巧，它可以有效地降低时间复杂度。其基本思想就是在众多可能的情况中“只考虑我需要用到的值”。下面用几个例子说明，如何运用离散化改进一个低效的，甚至根本不可能实现的算法。先看UVA10173 [http://acm.uva.es/p/v101/10173.html]题目意思很简单，给定平面上n个点的坐标，求能够覆盖这些点的最小的矩形面积。由于不知道这个矩形到底有倾斜多
机器学习——连续型特征离散化
小白兔的窝
01-03 1万+
在特征工程中，特别是logistic regression上，需要把一些连续特征进行离散化处理。离散化除了一些计算方面等等好处，还可以引入非线性特性，也可以很方便的做cross-feature。离散特征的增加和减少都很容易，易于模型的快速迭代。此外，噪声很大的环境中，离散化可以降低特征中包含的噪声，提升特征的表达能力。 连续特征离散化最常用的方法： （1）划分区间 如1-100岁可以划分为：
数据挖掘算法之离散化和二元化
深未来技术
02-06 1037
离散化和二元化 有些数据挖掘算法，特别是某些分类算法，要求数据是分类属性形式。发现关联模式的算法要求数据是二元属性形式。这样，常常需要将连续属性变换成分类属性（离散化，discretization），并且连续和离散属性可能都需要变换成一个或多个二元属性（二元化，binarization）。此外，如果一个分类属性具有大量不同值（类别），或者某些值出现不频繁，则对于某些数据挖掘任务，通过合并某些值减...
离散化方法
weixin_33828101的博客
06-13 428
个人笔记，仅供复习1.概念：离散化就是把无限空间的有限个体映射到有限空间去，从而大幅节省空间或时间。基本思想就是在众多可能的情况中“只考虑我需要用的值”2.适用范围：除了对于较大整数需要使用离散化之外，对于一些需要使用整型数据结构，但给出的数据却是小数的也可以使用离散化，将其索引为整数就可以了。3.一般步奏：排序去重建立索引4.例题：Uva12171// UVa1...
离散化详解（两种方法）
繁凡さん的博客
04-09 1万+
离散化 在一些问题中，我们只关心 n 个数字之间的相对大小关系，而不关心它 们具体是多少。 因此，我们可以用一种叫离散化的技术来将数字映射到 1 ∼ n 的整数， 从而降低问题规模，简化运算。 通常的实现方法是将所有数字排序，然后再重新遍历一遍所有的数字， 通过二分查找找到它们的 “排名”，然后用排名来代替对应的数字。 #include<iostream> #include<st...
一个漂亮的毕业设计模板
10-01
一个漂亮的毕业设计模板，供参考学习毕业设计写作技巧
朴素贝叶斯分类器对THUCNews数据集进行新闻分类_naive_bayes.zip
最新发布
10-01
朴素贝叶斯分类器对THUCNews数据集进行新闻分类_naive_bayes
基于Java语言开发的ktapis风控系统设计源码
10-01
本项目为基于Java语言构建的ktapis风控系统设计源码，包含32个文件，涵盖18个Java源文件、6个XML配置文件、3个Markdown文件、1个Git忽略文件、1个属性文件、1个证书文件、1个JSON文件、1个密钥文件，旨在提供全面的风控解决方案。
流体离散化P3+P3
03-09
流体离散化是指将连续的流体问题转化为离散的数值计算问题的过程。P3+P3是一种常用的流体离散化方法，它是基于有限元方法的一种高阶精度离散化方法。 在P3+P3方法中，流体域被划分为一系列的单元，每个单元内部的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值