2. 程式人生 > 其它 >noip模擬測試31

noip模擬測試31

阿新 • • 發佈：2021-08-06

終於有時間寫部落格了，前面一直咕咕咕都快變成一隻公雞了......這次考試，真的很意外，我在考場上覺得自己打出了T1的正解，樣例一拍就過，還跑得嘎嘎快，然後T2，T3碼了兩個暴力，覺得自己應該能100pts+,結果竟然....爆蛋了，T1思路出現了問題，T2打假了，T3TLE飛起，但是收穫還是有的，以後注意多加思考，看看自己的思路有沒有正確性，還有，一定要用暴力程式進行驗證（暴力不要打假...），樣例真是太水了....

T1 Game

思路：最大得分可以利用線段樹很容易求出，如果沒有字典序最大的限制，那麼這道題就非常簡單，但這只是如果，現在這道題有了雙重限制，聽某巨佬的敘述，得知一般有雙重限制的題一般有兩種思考方向，一種是二分，另一種是主席樹，那麼很顯然

，這道題我們可以考慮二分的思想，具體來說就是我們先通過線段樹求出最大得分，然後考慮這樣一件事情，如果有一對點可以對答案造成貢獻，那麼我們將他們同時刪去必然會使更新後的最大得分-1，這樣我們就可以進行二分查找了，對於可以造成貢獻的點，我們二分出他可以對應的最大的另外一個點，具體實現見程式碼：

AC_code 


#include<bits/stdc++.h>
#define re register int
#define ii inline int
#define iv inline void
#define lc (rt<<1)
#define rc (rt<<1|1)
using namespace std;
const int N=200010;
const int INF=1e9+10;
int n;
int a[N],b[N];
multiset<int> sm;
ii read()
{
	int x=0;
	bool f=1;
	char ch=getchar();
	while(ch<'0'||ch>'9')
	{
		if(ch=='-')
			f=0;
		ch=getchar();
	}
	while(ch>='0'&&ch<='9')
	{
		x=(x<<1)+(x<<3)+(ch^48);
		ch=getchar();
	}
	return f?x:(-x);
}
struct Segment_Tree
{
	int A[N<<2],B[N<<2],sum[N<<2];
	iv pp(int rt)
	{
		int u=min(A[lc],B[rc]);
		sum[rt]=sum[lc]+sum[rc]+u;
		A[rt]=A[lc]+A[rc]-u;
		B[rt]=B[lc]+B[rc]-u;
	}
	iv insert(int rt,int l,int r,int p,int x,int y)
	{
		if(l==r)
		{
			A[rt]+=x;
			B[rt]+=y;
			return;
		}
		int mid=(l+r)>>1;
		if(mid>=p)
			insert(lc,l,mid,p,x,y);
		else
			insert(rc,mid+1,r,p,x,y);
		pp(rt);
	}
}T;
int main()
{
	const int N=100000;
    n=read();
    for(re i=1;i<=n;i++)
    {
    	a[i]=read();
    	T.insert(1,1,N,a[i],1,0);
    }
    for(re i=1;i<=n;i++)
    {
    	b[i]=read();
    	T.insert(1,1,N,b[i],0,1);
    	sm.insert(b[i]);
    }
    int ans=T.sum[1];
    for(re i=1;i<=n;i++)
    {
    	int l=a[i]+1,r=*(--sm.end()),out=-1;
    	T.insert(1,1,N,a[i],-1,0);
    	while(l<=r)
    	{
    		int mid=(l+r)>>1;
    		T.insert(1,1,N,mid,0,-1);
    		if(T.sum[1]+1==ans)
    		{
    			l=mid+1;
    			out=mid;
    		}
    		else
    			r=mid-1;
    		T.insert(1,1,N,mid,0,1);
    	}
    	if(out!=-1)
    	{
    		--ans;
    		sm.erase(sm.find(out));
    		T.insert(1,1,N,out,0,-1);
    		printf("%d ",out);
    	}
  	else
 
    	{
    		l=1,r=a[i],out;
    		while(l<=r)
    		{
    			int mid=(l+r)>>1;
    			T.insert(1,1,N,mid,0,-1);
    			if(T.sum[1]==ans)
    			{
    				l=mid+1;
    				out=mid;
    			}
    			else
    				r=mid-1;
    			T.insert(1,1,N,mid,0,1);
    		}
    		printf("%d ",out);
    		sm.erase(sm.find(out));
    		T.insert(1,1,N,out,0,-1);
    	}
    }
    return 0;
}

T2 Time

這道題，或者說是這一種對數列進行排列的題，我是比較不自信的，因為自己不怎麼有思路，導致我沒有留出時間進行思考，這也是一個教訓，逃避不是永久的辦法，只有自己敢去想，去做，才能解決問題。
思路：這道題要求小的數字往兩邊靠，那很顯然，如果要做到最小操作次數就要比較向左還是向右移動更優，可以利用線段樹或者樹狀陣列實現，演算法的正確性在於，當我們將小數字向邊緣移動的時候，我們都會將比他大的數字向中心移動，所以我們只需要利用貪心的思想只考慮使當前最優即可。

AC_code 

#include<bits/stdc++.h>
#define re register int
#define ii inline int
#define iv inline void
#define lc (rt<<1)
#define rc (rt<<1|1)
#define mid ((l+r)>>1)
using namespace std;
const int N=1e5+10;
const int INF=1e9+10;
int n;
deque<int>q[N];
ii read()
{
	int x=0;
	bool f=1;
	char ch=getchar();
	while(ch<'0'||ch>'9')
	{
		if(ch=='-')
			f=0;
		ch=getchar();
	}
	while(ch>='0'&&ch<='9')
	{
		x=(x<<1)+(x<<3)+(ch^48);
		ch=getchar();
	}
	return f?x:(-x);
}
struct Segment_Tree
{
	int sum[N<<2];
	iv pp(int rt)
	{
		sum[rt]=sum[lc]+sum[rc];
	}
	iv insert(int rt,int l,int r,int p,int z)
	{
		if(l==r)
		{
			sum[rt]+=z;
			return;
		}
		if(mid>=p)
			insert(lc,l,mid,p,z);
		else
			insert(rc,mid+1,r,p,z);
		pp(rt);
	}
	ii query(int rt,int l,int r,int L,int R)
	{
		if(L>R)
			return 0;
		if(L<=l&&r<=R)
			return sum[rt];
		if(mid>=R)
			return query(lc,l,mid,L,R);
		if(mid<L)
			return query(rc,mid+1,r,L,R);
		return query(lc,l,mid,L,R)+query(rc,mid+1,r,L,R);
	}
}T;
int main()
{
	int ans=0;
	n=read();
	for(re i=1;i<=n;i++)
	{
		q[read()].push_back(i);
		T.insert(1,1,n,i,1);	
	}
	for(re i=1;i<=n;i++)
	{
		while(!q[i].empty())
		{
			int l=q[i].front(),r=q[i].back();
			int sl=T.query(1,1,n,1,l-1),sr=T.query(1,1,n,1,n)-T.query(1,1,n,1,r);
			if(sl<=sr)
			{
				ans+=sl;
				T.insert(1,1,n,l,-1);
				q[i].pop_front();
			}						
			else
			{
				ans+=sr;
				T.insert(1,1,n,r,-1);
				q[i].pop_back();
			}
		}
	}
	printf("%d\n",ans);
    return 0;
}

T3 Cover

好吧，這道題怪我沒有認真聽課，區間兩兩之間只有包含和不相交的關係滿足這個條件，他們的包含關係一定會構成一顆樹，那麼這道題顯然就是一個樹形DP（而不是我寫的區間DP），記 \(f_{i,j}\)表示在 i 為根的子樹中點被覆蓋的最多次數為 j 的最優答案,轉移
的時候首先將所有子樹的答案直接合並,然後考慮點 i 的貢獻 \(f_{i,j}=max(f_{i,j},f_{i,j-1}+val)\) , 這樣樸素的DP方程顯然時間複雜度會爆炸，考慮優化，我們考慮答案更新的過程，我們利用包含關係構建一顆樹，那麼我們將子樹合併的時候，當前的節點會儲存多個val，包括自己本身的，還有自己的兒子合併得到的，這種答案屬於同一層，我們需要不同層之間的轉移。也就是到達跟節點的時候我們需要不斷從左右區間中分別拿出最大值，這就是我們需要的答案，那麼我們就可以利用一個 set ，通過一個合併的操作插入值並排序，具體實現見程式碼：

AC_code 


#include<bits/stdc++.h>
#define re register int
#define ii inline int
#define iv inline void
#define lc (rt<<1)
#define rc (rt<<1|1)
#define mid ((l+r)>>1)
using namespace std;
const int N=1e5+10;
const int INF=1e9+10;
int n;
deque<int>q[N];
ii read()
{
	int x=0;
	bool f=1;
	char ch=getchar();
	while(ch<'0'||ch>'9')
	{
		if(ch=='-')
			f=0;
		ch=getchar();
	}
	while(ch>='0'&&ch<='9')
	{
		x=(x<<1)+(x<<3)+(ch^48);
		ch=getchar();
	}
	return f?x:(-x);
}
struct Segment_Tree
{
	int sum[N<<2];
	iv pp(int rt)
	{
		sum[rt]=sum[lc]+sum[rc];
	}
	iv insert(int rt,int l,int r,int p,int z)
	{
		if(l==r)
		{
			sum[rt]+=z;
			return;
		}
		if(mid>=p)
			insert(lc,l,mid,p,z);
		else
			insert(rc,mid+1,r,p,z);
		pp(rt);
	}
	ii query(int rt,int l,int r,int L,int R)
	{
		if(L>R)
			return 0;
		if(L<=l&&r<=R)
			return sum[rt];
		if(mid>=R)
			return query(lc,l,mid,L,R);
		if(mid<L)
			return query(rc,mid+1,r,L,R);
		return query(lc,l,mid,L,R)+query(rc,mid+1,r,L,R);
	}
}T;
int main()
{
	int ans=0;
	n=read();
	for(re i=1;i<=n;i++)
	{
		q[read()].push_back(i);
		T.insert(1,1,n,i,1);	
	}
	for(re i=1;i<=n;i++)
	{
		while(!q[i].empty())
		{
			int l=q[i].front(),r=q[i].back();
			int sl=T.query(1,1,n,1,l-1),sr=T.query(1,1,n,1,n)-T.query(1,1,n,1,r);
			if(sl<=sr)
			{
				ans+=sl;
				T.insert(1,1,n,l,-1);
				q[i].pop_front();
			}						
			else
			{
				ans+=sr;
				T.insert(1,1,n,r,-1);
				q[i].pop_back();
			}
		}
	}
	printf("%d\n",ans);
    return 0;
}

相關推薦

noip模擬測試31

終於有時間寫部落格了，前面一直咕咕咕都快變成一隻公雞了......這次考試，真的很意外，我在考場上覺得自己打出了T1的正解，樣例一拍就過，還跑得嘎嘎快，然後T2，T3碼了兩個暴力，覺得自己應該能100pts+,結果竟然.

noip模擬測試33

noip模擬測試33 t1 合併集合 sb題，裸的石子合併，考試沒看見有環，掛成20分 程式碼：

noip模擬測試10

T1 這道題在考場上想到了二維字首和，就是自己算字首和的方式有點麻煩，導致花的時間較長，但還是成功搞了出來。

noip模擬測試20

考試總結：這次考試，我非常真實地感覺到了自己能力的提高，具體來說，在之前的考試中，讀完題之後我只會想到暴力的思路，甚至有的題連暴力都打不出來，但是這次在考場上我已經有了自己的一些想法，有了一個深入思考

noip模擬測試22

考試總結：這次考試題，有好多部分分，導致了我在考試過程中一心想拿到這些部分分，對於正解沒有留出時間進行思考，這是一個教訓，在以後的考試中我一定要留出足夠的思考時間，不要被部分分限制。還有，我的部分分也

noip模擬測試23

考試總結：這次考試，成績和自己的預估分數差距有點大，問題主要是出在了第一題上，我當時讀完題，就想到了線段樹，很快就碼完了，但是我當時沒有想到的兩個關鍵問題是：1.沒有想到離散化 2.對於異或的情況沒有分類

noip模擬測試34

這次考試，全靠第一題撐著了，第一題我畫了畫圖，就看出了二分答案，然後差不多半個小時就碼的差不多了，又加上了一點小優化，但是沒拿到滿分，失誤有兩點，1.二分之前沒有特判0的情況 2.這屬於一個知識性問題，我當

noip模擬測試38

這兩天考試覺得自己不在狀態，做題也沒有什麼思路，休整一下，儘快恢復狀態。

noip模擬測試36

這次考試，題目比較有難度，考場上我只有T1有65分的思路，T3有一個暴力的思路，T2完全不會打，但是這次我把自己應該得到的分數都拿到了，也算是一個進步吧。

noip模擬測試52

這套題總體來說比較簡單，但是有一些分數我沒有拿到，先說T1，我10分鐘左右打完了60分的暴力，然後就開始打表找規律，好像只有我去找了迴圈節，找規律找了一個多小時，到八點四十的時候我還沒有正解做法，就直接棄掉

2021.11.18-NOIP模擬測試信心賽

2021.11.18-NOIP模擬信心賽 前言 太蒟蒻了，信心賽打的都快沒信心了，giao T1\\(\\color{green}100\\)題目

「NOIP」 聯賽模擬測試33

「NOIP」 聯賽模擬測試33 合併集合 不會的建議直接重學 區間\\(dp\\)。 跟石子合併很像，發現 \\(n\\) 很小，直接 \\(n^3\\) 預處理貢獻就行了，然後直接 \\(dp\\)，懶得講了。

「NOIP」 聯賽模擬測試44

「NOIP」 聯賽模擬測試44 long long ago,I remember someone set a flag... 樹 什麼都能做，如果你非得樹剖加一個 \\(log\\)，應該也能過。

noip模擬9[斐波那契·數顏色·分組](洛谷模擬測試)

這次考試還是挺好的 畢竟第一題被我給A了，也怪這題太簡單，規律一眼就看出來了，但是除了第一題，剩下的我只有30pts，還是菜

noip模擬31 Game Time Cover

noip模擬31 Game Time Cover 考場上順序開題。 \\(\\mathrm{A.}\\mathbb{Game}\\)：資料結構 \\(\\mathrm{B.}\\mathbb{Time}\\)：資料結構

NOIP模擬2021.7.31

1、 演出邀請 神奇的模擬題。 我們可以考慮如果我們以某種合理的方式掃一遍所有的演員組合，就可以得到答案。

[NOIP模擬]相遇/行程的交集

Description 豪哥生活在一個 n 個點的樹形城市裡面，每一天都要走來走去。雖然走的是比較的 多，但是豪哥在這個城市裡面的朋友並不是很多。 當某一天，猴哥給他展現了一下大佬風範之後，豪哥決定要獲得一些交往機會來

「NOIP模擬賽」日曆遊戲

「NOIP模擬賽」日曆遊戲 「問題描述」 moreD和moreD的寵物CD正在玩一個日曆遊戲，開始時，他們從1900年1月1日到2012年12月22日（你懂的……）選一個日期開始，依次按照如下規則之一向後跳日期：

【賈志豪NOIP模擬題】慰問員工 cheer 【最小生成樹】【對邊權值的一些處理】

Description 　　LongDD 變得非常懶, 他不想再繼續維護供員工之間供通行的道路. 道路被用來連線 N(5 <= N <= 10,000)個房子, 房子被連續地編號為 1..N. 每一個房子都是一個員工的家. LongDD 計劃除去 P(N-1 &

HEAT OJ #39. 【2020.9.3 NOIP模擬賽 T3】C

題意簡述 給一長為 \\(10^6\\) 的字串，求有多少子串能夠看作合法括號序列（要求配對的“括號”字母相同）。