POJ1716-Integer Intervals

 

轉載請註明出處：優YoU  http://user.qzone.qq.com/289065406/blog/1306975576

 

大致題意：

給出數軸上的n個區間，每個區間都是連續的int區間。

現在要在數軸上任意取一堆元素，構成一個元素集合V

要求每個區間和元素集合V的交集至少有兩個不同的元素

求集合V最小的元素個數。

 

解題思路：

一、貪心演算法

先對所有區間按末端點排序

取第i個區間的最後兩個元素Selem和Eelem

若第i+1個區間包含了這兩個元素，則跳到下一個區間所取的元素個數+0

若第i+1個區間只包含了這兩個元素中的一個（由於有序，所以必定是包含Eelem），則取第i+1個區間的最後一個元素，所取的元素個數+1。為了方便下一區間的比較，更新Selem和Eelem的值，使他們為當前V集合中最後的兩個元素。

若第i+1個區間沒有包含這兩個元素，則第i+1個區間的最後兩個元素，所取的元素個數+2。為了方便下一區間的比較，更新Selem和Eelem的值，使他們為當前V集合中最後的兩個元素。

 

Selem初始化為第一個區間的最後倒數第2個元素

Eelem初始化為第一個區間的最後的元素

所取的元素個數初始化為2 (就是Selem和Eelem)

 

二、差分約束+Relax

設s[x] = 從0
到x 的所有在集合中的數的個數

則ai到bi的個數即S[bi] - S[ai-1]。
因此有

(1) S[bi] - S[ai-1] >= 2。

又根據s[x]本身的性質，
後面的一定不比前面的小，後面的最多比前面多一，有：
(2)  s[i + 1] - s[i] >= 0
(3)  s[i + 1] - s[i] <= 1
故建圖,使圖中每一組邊，均滿足（注意三條式子的不等號方向要一致，這個很重要）:
S[ai - 1] <= S[bi] - 2
S[i] <= S[i - 1] + 1
S[i - 1] <= S[i]

上面三式，可把s[x]看作源點（假設存在）到各點的最短距離，初始化為0；

常數為邊(ai – 1，bi)的邊權

當存在不滿足這三條式子的邊時，對這條邊進行Relax操作，更新不等號左邊的變數。

其實就是Bellman-Ford演算法的核心部分

if( S[ai - 1] > S[bi] – 2 )   S[ai - 1] = S[bi] – 2
；

if( S[i] > S[i - 1] + 1 )   S[i] > S[i - 1] + 1
；

if( S[i - 1] > S[i] )   S[i - 1] = S[i]
；

 

最後源點到最大頂點的距離減去源點到最小頂點的距離就是所求（其實一個單位距離就代表V中的一個元素；最小頂點到最大頂點其實就是所有輸入的區間中，最小的左端點到最大的右端點這個範圍）。

 

注意，經過我測試，本題變數的定義均要從全域定義，否則WA，什麼原因我也不清楚（變數和數組的大小都只有10000，真是神了），只能說POJ太虐人了，白白耗了我一堆時間。

 

//Memory Time //284K   94MS/*Greed*/#include<iostream>#include<algorithm>using namespace std;typedef class{public:int s,e;}interval;      //間隔（區間）int cmp(const void* a,const void* b){interval* x=(interval*)a;interval* y=(interval*)b;return (x->e) - (y->e);  //對區間按末端點排序}int main(void){int n; //區間數while(cin>>n){interval* inter=new interval[n];for(int i=0;i<n;i++)cin>>inter[i].s>>inter[i].e;qsort(inter,n,sizeof(interval),cmp);  //對區間按末端點排序int Selem=inter[0].e-1 , Eelem=inter[0].e;  //當前區間所取的兩個元素，初始化為第0個區間最後兩個元素int sum=2;  //至少取sum個元素才能保證每個區間至少含有其中的2個元素for(int k=1;k<n;k++)if(inter[k].s<=Selem)  //前一個區間所取的兩個元素都在當前區間內continue;  //則當前區間無需取任何元素else if(inter[k].s<=Eelem)  //前一個區間所取的只有一個元素在當前區間內{Selem=Eelem;Eelem=inter[k].e;  //按序更新當前區間所取的兩個元素：Selem與Eelemsum++;  //Eelem是新取的一個元素}else  //前一個區間所取的沒有一個元素在當前區間內{Selem=inter[k].e-1;Eelem=inter[k].e;  //按序更新當前區間所取的兩個元素：Selem與Eelemsum+=2;  //Selem與Eelem是新取的兩個元素}cout<<sum<<endl;delete inter;}return 0;}

 

 

=========華麗的分割線=========

 

 

//Memory Time //296K  282MS /*Difference Constraints*/#include<iostream>using namespace std;const int inf=20000;class{public:int s,e;}inter[10001];int dist[10001];  //源點到各點的距離int n; //區間數int upli;int doli; // UpLimit , Downlimit 上下限int main(int i){while(cin>>n){upli=0;doli=inf;/*Input*/for(i=0;i<n;i++){int a,b;cin>>a>>b;inter[i].s=a;inter[i].e=b+1;if(doli>inter[i].s)  //尋找最小的頂點doli=inter[i].s;if(upli<inter[i].e)  //尋找最大的頂點，inter[k].e必大於inter[k].s，因此無需再與inter[k].s比較upli=inter[i].e;dist[i]=0; //初始化源點到各點的距離}/*Bellman-Ford:Relax*/bool flag=true;while(flag)  //只要某一次Relax沒有更新，說明最短路徑已經尋找完畢，或者部分點不可達，可以跳出relax{flag=false;for(i=0;i<n;i++)if(dist[ inter[i].s ]>dist[ inter[i].e ]-2){dist[ inter[i].s ]=dist[ inter[i].e ]-2;flag=true;  //Relax對路徑有更新}for(i=doli;i<upli;i++)if(dist[i+1]>dist[i]+1){dist[i+1]=dist[i]+1;flag=true;}for(i=upli-1;i>=doli;i--)   //這裡逆向鬆弛(從upli到doli)比正向鬆弛(從doli到upli)快了500msif(dist[i] > dist[i+1]){dist[i] = dist[i+1];flag = true;}}cout<<dist[upli]-dist[doli]<<endl;}return 0;}