7.20 模拟赛总结 [邻项交换] + [决策单调性]

癹魃♭

已于 2024-07-23 21:12:00 修改

阅读量595

点赞数 22

分类专栏： TY 集训总结文章标签：算法 c++

于 2024-07-23 21:08:22 首次发布

本文链接：https://blog.csdn.net/qq_56326461/article/details/140608237

版权

TY 集训总结专栏收录该内容

10 篇文章 0 订阅

订阅专栏

只放题解喽

题解

- T1
- T2
- T3
- T4

T1

在这里插入图片描述
等价于维护差分数组，数据范围较小，map 套 vector 维护即可

更大的数据范围可以 hash 做

T2

在这里插入图片描述
神奇贪心

本题关键在于定序，考虑顺序确定后答案怎么求

设 $f_i$ 表示第 $i$ 件衣服烘干完的时间，显然有转移： $f_i=max(f_{i-1},\sum_{k=1}^{i}a_k)+b_i$ ，认为 $f_0=0$

对于顺序，考虑邻项交换，贴一篇大佬的 blog

对于邻项 $x, y$ ，设前面烘干时间为 $f$ ， $\sum a_k$ 为 $S$ ，显然我们希望让考虑完 $x, y$ 后的 $f$ 尽可能小

先 $x$ 后 $y$ ， $f_x=max(f,S+a_x)+b_x$ ， $f_y=max(f+b_x+b_y,S+a_x+b_x+b_y,S+a_x+a_y+b_y)$
先 $y$ 后 $x$ ，将 $(x, y)$ 轮换后可得到 $f'_x=max(f+b_y+b_x,S+a_y+b_y+b_x,S+a_y+a_x+b_x)$

何时可以不交换排好顺序的 $x, y$ 呢？

显然应该 $f_y\leq f'_x（1）$ ，开始化式子，由于 $f+b_x+b_y$ 相同，我们可以将其约掉

即： $max(S+a_x+b_x+b_y,S+a_x+a_y+b_y)\leq max(S+a_y+b_y+b_x,S+a_y+a_x+b_x) （2）$

注意，这里约掉前后的两个式子是不等价的， $max(a,c)\leq max(b,c)$ 不等价于 $a\leq b$ ，但在本题这么做不会出错，简单讨论可以发现是对的（其实告诉我们这里只需要化成必须交换的充分条件就行）

接下来继续化：

$a_x+b_y+max(b_x,a_y)\leq a_y+b_x+max(b_y,a_x)$

$min(a_x,b_y)\leq min(a_y,b_x)$

那么我们 $c m p$ 函数里只需要这么写 $min(a_x,b_y)<min(a_y,b_x)$ 就做完了 —— 吗？

并不正确！关于邻项交换还有很多限制

对于我们定义的一种比较规则 $X < Y$ ，需要满足 严格弱序：

传递性，即 $X < Y, Y < Z$ ，就有 $X < Z$
否则，对于最终排好的序列中的 $X, Y, Z$ ，虽然对于邻项满足 $X < Y, Y < Z$ ，但是我们可以先交换 $X, Y$ 使答案损失一部分，但接下来可能出现 $X > Z$ ，然后交换二者使得答案比以前更优
不可比性，若 $X ≮ Y, Y ≮ X, Y ≮ Z, Z ≮ Y$ ，那么 $X ≮ Z, Z ≮ X$
可以简单理解为 $X = Y, Y = Z$ ，那么 $X = Z$
否则，同上，交换 $X, Y$ 后可能出现新的逆序，使得答案更优

本题来说，我们定义的比较规则 $\to min(a_x,b_y)<min(a_y,b_x)$ ，满足 1，但不满足 2

对于这个的验证方法参考大佬的 $b l o g$ ，大力发挥 OIer 的优势

那么接下来我们需要定义一种能够同时满足上述两个条件的比较方式

当 $min(a_x,b_y)=min(a_y,b_x)$ 时，我们感性理解可以把 $a, b$ 小的放前面（这个其实比较随意，因为第一步已经保证了答案最优性，接下来只需要满足严格弱序就行），于是得到了：

$\begin{Bmatrix} min(a_x,b_y)<min(a_y,b_x)\ \ \ (if\ \ min(a_x,b_y)\ne min(a_y,b_x))\\a_x<a_y \ \ \ \ \ (otherwise) \end{Bmatrix}$

这个比较方式既满足严格弱序，又能够使得邻项交换后不会使得答案变优，于是我们就得到了正确答案

总结几点：

推式子时找充分条件就行了，不一定得充要

贪心时只考虑相邻两项，只要是满足严格弱序，且邻项交换不会使答案变优，那么就是最优方案

贴一个 checker

int a[N] , b[N] , w[N] ;
bool cmp ( int x , int y )
{
	if( min(a[x],b[y])!=min(a[y],b[x]) ) return min(a[x],b[y]) < min(a[y],b[x]) ;
	return a[x]<a[y] ;
}
bool check()
{
	int Max = 20 ;
	for( a[0] = 1 ; a[0] <= Max ; a[0] ++ ) {
	for( b[0] = 1 ; b[0] <= Max ; b[0] ++ ) {
		if( cmp(0,0) ) {
			printf("No self , %d %d\n" , a[0] , b[0] ) ;
			return 0 ;
		} // 验证自反性 
		for( a[1] = 1 ; a[1] <= Max ; a[1] ++ ) {
		for( b[1] = 1 ; b[1] <= Max ; b[1] ++ ) {
			if( cmp(0,1) && max(1/b[0],a[0]/b[1])>max(1/b[1],a[1]/b[0]) ) {
				printf("Not the best\n") ;
				return 0 ;
			} // 验证最优性 
			for( a[2] = 1 ; a[2] <= Max ; a[2] ++ ) {
			for( b[2] = 1 ; b[2] <= Max ; b[2] ++ ) {
				if( cmp(0,1) && cmp(1,2) && !cmp(0,2) ) {
					printf("No Trans\n") ;
					return 0 ;
				} // 验证传递性 
				if( !cmp(0,1)&&!cmp(1,0)&&!cmp(1,2)&&!cmp(2,1)&&(cmp(0,2)||cmp(2,0)) ) {
					printf("No comparability , (%d,%d) (%d,%d) (%d,%d)\n" , a[0] , b[0] , a[1] , b[1] , a[2] , b[2] ) ;
					return 0 ;
				} // 验证不可比性 
			}
			}
		}	
		}	
	}
	}
	return 1 ;
}

T3

大力发扬人类智慧！

在这里插入图片描述
先说暴力怎么做，枚举三角形，枚举点，判点是否在三角形里，通过面积法来实现

已知两种 $O(\frac{n^4}{w})$ 做法：

求出每条直线上方 / 下方点集，可以 $n^3$ 预处理，接下来枚举三角形， $bi t se t$ 上上下下与一下即可
注意到任选四个点都可以得到一组关于三角形的方程，也就是说需要花费 $O (n)$ 计算权值的三角形不多，那么对于当前 $i, j, k$ 三角形查找是否有 $(i, j, p), (j, k, p), (i, k, p)$ 权值均已求过的 $p$ ，若没有则 $O (n)$ 算，否则直接加加减减拼凑出来（及其恶心分讨）

下面说正解：

确定一个三角形就不得不枚举三个点了，尝试能不能枚举更少的点，来确定一些更基本的图形

在这里插入图片描述
对于每个点往 $x$ 轴上打投影，发现只求梯形就行了！

$S_{\Delta ABC}=S_{ADFC}-S_{ABED}-S_{BEFC}$

这样枚举两个点确定梯形，然后在 $O (n)$ 求权值即可

有些小细节

T4

在这里插入图片描述
好题，难题

本题的第一个难点在于读懂题

注意到 “可以证明答案一定是一个整数” ，我们开始手玩

发现每次绳子扫过的面积 必定是以上一个关键点为左下角，下一个关键点为右上角的矩形

考虑两个限制：

选点的限制实际上是个二维偏序上的 $L I S$ ，排序+树状数组可以做掉

对于面积，写一下转移式：

$dp_i=min(dp_j+(x_i-x_j)(y_i-y_j))，lis_i=lis_j+1\ 且\ x_j\leq x_i,y_j\leq y_i$

拆开式子感觉和斜优很像，但很遗憾这个关于 $j$ 的 双变量 式子不会做，而且也很难直接维护 Max 什么的

考虑限制分开做，先做 $L I S$ ；然后按 $L I S$ 分层，只考虑相邻层间的转移

容易发现：每层中随 $x$ 增大， $y$ 单调不升

那么对于第 $i$ 层的点 $j$ ， $i - 1$ 层中合法的决策 $p$ 是一段连续的区间…

然后…优化不动了，但我们发现这样写完交上去获得了 95pts 的好成绩！（逆天）

接下来，找找性质吧，然后就神奇的发现了这个有决策单调性

考虑四边形不等式，设 $W (i, j)$ 表示下一层的 $i$ 与本层的 $j$ 构成的矩形面积
在这里插入图片描述
对于 $a < b, i < j$ ，有 $W(i,a)+W(j,b)\geq W(i,b)+W(j,a)$ $(1)$

假设对于 $i$ 来说， $a$ 比 $b$ 优，即 $f_a+W(i,a)\leq f_b+W(i,b)$ $(2)$

$(1) + (2)$ ，可得 $f_a+W(j,a)\leq f_b+W(j,b)$ ，即对于 $j$ 来说， $a$ 比 $b$ 优

所以具有决策单调性

但是，本题与之前朴素的分治优化/二分队列优化的题目不太一样，因为决策有上下界限制！！

必须要满足 $x_j\leq x_i,y_j\leq y_i$ ，那么随着 $i$ 的枚举必然会删除、插入一些决策，与之前的只往后插入新决策不同

那么一个新的技巧：首先将 上一层 的所有决策建线段树，把 $i$ 这个“询问”的合法决策范围拆成 $l o g$ 个区间，放到上一层的线段树中，全部放完后，遍历线段树所有节点，对每个节点进行一次分治

这么做的好处是显然的，在一个在线段树节点中不用担心决策上下界变化，可以直接分治优化

分析复杂度：

考虑相邻两层，所有的询问一共会被放进 $cnt\times log$ 个区间（ $c n t$ 表示每层的节点数），枚举询问的复杂度没问题

遍历线段树节点时，每个节点进行分治的复杂度是 $len\times log$ ，那么对于线段树一层的总复杂度是 $cnt\times log$ ，共 $l o g$ 层，所以总复杂度 $cnt\times log^2$ ，最后所有层的总复杂度就是 $nlog^2$

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

typedef long long LL ;
const int N = 2e5+100 , M = 1e6+10 ; 

int n , m ;
struct nn
{
	int x , y ;
}a[N] ;
bool cmp( nn a , nn b )
{
	return a.x < b.x || (a.x==b.x&&a.y<b.y) ;
}
int f[N] ;
struct BIT
{
	int t[M] ;
	inline int lowbit( int x ) { return x&-x ; }
	void add( int p , int x ) {
		for( ; p <= m ; p += lowbit(p) ) t[p] = max( t[p] , x ) ;
	}
	int ask( int p ) {
		int res = 0 ;
		for( ; p ; p -= lowbit(p) ) res = max( res , t[p] ) ;
		return res ;
	}
} T ;
vector<int> ve[N] ;
// 达到 n^2 复杂度后再往下很难优化
// 观察 dp 式子十分朴素，考虑常用优化
// 发现是一个带上下界的决策单调性 
// 决策上下界都会变化时：线段树 把询问分成log个区间，每个区间内可以正常进行分治 
LL dp[N] ;
struct Segtree
{
	int l , r ;
	vector<int> q ;
}t[4*N] ;
void build( int p , int l , int r )
{
	t[p].l = l , t[p].r = r ;
	vector<int> tmp ;
	swap( tmp , t[p].q ) ;
	if( l == r ) {
		return ;
	}
	int mid = ( l + r ) >> 1 ;
	build( p<<1 , l , mid ) ; build( p<<1|1 , mid+1 , r ) ;
}
void push( int p , int l , int r , int x )
{
	if( l <= t[p].l && t[p].r <= r ) {
		t[p].q.push_back( x ) ;
		return ;
	}
	int mid = ( t[p].l + t[p].r ) >> 1 ;
	if( l <= mid ) push( p<<1 , l , r , x ) ;
	if( r > mid ) push( p<<1|1 , l , r , x ) ;
}
vector<int> q , J ;
inline LL Val( int x , int y ) // y->x
{
	return dp[y]+1LL*(a[x].x-a[y].x)*(a[x].y-a[y].y) ;
}
void solve( int l , int r , int ql , int qr )
{
	if( ql > qr ) return ;
	int mid = (ql+qr) >> 1 , j ;
	LL V = 1e18 ;
	for(int i = l ; i <= r ; i ++ ) {
		if( V > Val(q[mid],J[i]) ) {
			V = Val(q[mid],J[i]) ;
			j = i ;
		}
	}
	dp[q[mid]] = min( dp[q[mid]] , V ) ;
	solve( j , r , ql , mid-1 ) ;
	solve( l , j , mid+1 , qr ) ;
}
void work( int p )
{
	if( t[p].q.size() > 0 ) {
		swap( q , t[p].q ) ;
		solve( t[p].l , t[p].r , 0 , q.size()-1 ) ;
	}
	if( t[p].l == t[p].r ) {
		return ;
	}
	work( p<<1 ) ; work( p<<1|1 ) ;
}

int main()
{
	scanf("%d%d" , &n , &m ) ;
	for(int i = 1 ; i <= n ; i ++ ) {
		scanf("%d%d" , &a[i].x , &a[i].y ) ;
	}
	a[n+1].x = m , a[n+1].y = m ;
	sort( a+1 , a+n+1 , cmp ) ;
	int Max = 0 ;
	ve[0].push_back( 0 ) ;
	for(int i = 1 ; i <= n ; i ++ ) {
		f[i] = T.ask( a[i].y ) + 1 ;
		T.add( a[i].y , f[i] ) ;
		ve[f[i]].push_back( i ) ;
		Max = max( Max , f[i] ) ;
	}
	Max ++ ;
	ve[Max].push_back( n+1 ) ;
	memset( dp , 0x3f , sizeof dp ) ;
	dp[0] = 0 ;
	for(int i = 1 ; i <= Max ; i ++ ) {
		build( 1 , 0 , ve[i-1].size()-1 ) ;
		int p = 0 , q = 0 ;
		for(int j : ve[i] ) {
			while( p < ve[i-1].size() && a[ve[i-1][p]].y > a[j].y ) p ++ ;
			while( q+1 < ve[i-1].size() && a[ve[i-1][q+1]].x <= a[j].x ) q ++ ;
			if( p <= q ) {
				push( 1 , p , q , j ) ;
			}
		}
		swap( J , ve[i-1] ) ;
		work( 1 ) ;
		swap( J , ve[i-1] ) ;
	}
	printf("%lld\n" , dp[n+1] ) ;
	return 0 ;
}