棰樻剰錛?span style="font-size: 10pt; ">鏈?/span>3涓漢
姣忎釜浜烘湁n涓壒寰佸?/span>(1 ≤ n ≤ 4 000)
姹傛瘡涓漢閮芥湁鐨勭壒寰佸兼湁鍑犱釜錛?/span>(鐗瑰緛鍊?/span> ≤ 10^9)
鍒嗘瀽錛氭垜鎶婃墍鏈夌殑鏁版嵁鏀懼埌涓涓暟緇勯噷鎺掑簭錛屾湁榪炵畫涓変釜鐩稿悓鐨勮瘽灝辨槸涓涓叡鍚岀壒寰併?br />
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
int arr[12003];
int main()
{
int n;
scanf("%d",&n);
int i;
for(i=0;i<n;++i)
{
scanf("%d",&arr[i]);
}
scanf("%d",&n);
n+=i;
for(;i<n;++i)
{
scanf("%d",&arr[i]);
}
scanf("%d",&n);
n+=i;
for(;i<n;++i)
{
scanf("%d",&arr[i]);
}
sort(arr,arr+n);
int cnt=0;
for(int j=0;j<n-2;++j)
{
if(arr[j]==arr[j+1]&&arr[j+1]==arr[j+2])
{
++cnt;
}
}
printf("%d\n",cnt);
return 0;
}
#include<cstdio>
#include<algorithm>
using namespace std;
int arr[12003];
int main()
{
int n;
scanf("%d",&n);
int i;
for(i=0;i<n;++i)
{
scanf("%d",&arr[i]);
}
scanf("%d",&n);
n+=i;
for(;i<n;++i)
{
scanf("%d",&arr[i]);
}
scanf("%d",&n);
n+=i;
for(;i<n;++i)
{
scanf("%d",&arr[i]);
}
sort(arr,arr+n);
int cnt=0;
for(int j=0;j<n-2;++j)
{
if(arr[j]==arr[j+1]&&arr[j+1]==arr[j+2])
{
++cnt;
}
}
printf("%d\n",cnt);
return 0;
}
]]>
棰樻剰錛?/span>k涓烘瘡鍒嗛挓鍙互閫氳鐨勬渶澶ц濺杈嗐備竴鍏辨湁n涓垎閽燂紝緇欏嚭姣忓垎閽熸柊鍑虹幇鐨勮濺杈嗘暟錛岄棶榪囦簡n鍒嗛挓鍚庤繕鍓╀笅澶氬皯杈嗚濺娌℃湁閫氳銆?/span>
鍒嗘瀽錛氱洿鎺ユā鎷熷氨鍙互浜嗐?br />
#include<iostream>
#include<cstdio>
using namespace std;
int main()
{
int k,n;
scanf("%d %d",&k,&n);
int sum=0,val;
for(int i=0;i<n;++i)
{
scanf("%d",&val);
sum+=val;
sum=sum>k?sum-k:0;
}
printf("%d\n",sum);
return 0;
}
#include<cstdio>
using namespace std;
int main()
{
int k,n;
scanf("%d %d",&k,&n);
int sum=0,val;
for(int i=0;i<n;++i)
{
scanf("%d",&val);
sum+=val;
sum=sum>k?sum-k:0;
}
printf("%d\n",sum);
return 0;
}
]]>
寰堥仐鎲炬瘮璧涚殑鏃跺欐病鍋氬嚭鏉ワ紝褰撴椂鐢ㄨ椽蹇冪殑鏂規硶鍐欒繃錛屽彲鏄濊礬鏈夐棶棰橈紝WA浜嗐傝В棰樻姤鍛婁笂闈㈠彧璇存槸璐績錛屼絾鍏蜂綋鎬庝箞鍐欐病鏈夎銆備簬鏄垜灝卞皾璇曚簡涓浜涜椽蹇冩兂娉曪紝緇堜簬AC銆?4ms鐨勬椂闂磋繕鎸洪潬鍓嶇殑銆?/span>
棰樻剰錛歂涓侀紶媧炲拰N涓侀紶錛岃侀紶鏈変釜鍏磋叮鍖洪棿[s,t]錛屽氨鏄鑰侀紶浼氬榪欎釜鑼冨洿鍐呯殑媧炴劅鍏磋叮錛屼粬浠細鍗犻鑷繁鎰熷叴瓚ｇ殑媧炪傛湁涓涓叴瓚ｆ嘗鍔ㄨ寖鍥碖錛屾眰涓涓渶灝忕殑K浣垮緱鎵鏈夌殑鑰侀紶閮借兘鍗犻鑷繁鎰熷叴瓚ｇ殑媧炪?/p>
鍒嗘瀽錛氭寜鐓у乏杈瑰尯闂翠粠灝忓埌澶ф帓搴忥紝鐒跺悗寮濮嬫灇涓炬瘡涓涓尯闂達紝浠庡尯闂村彸杈圭殑绔偣寮濮嬫斁錛屽鏋滈偅涓綅緗凡緇忔湁鑰侀紶鐨勮瘽錛屽氨鍚戝墠閬嶅巻涓閬嶇湅鍓嶈竟鐨勬礊鏄惁宸叉弧錛屾病鏈夋弧鐨勮瘽灝卞悜鍓嶉亶鍘嗭紝閬囧埌宸︾鐐圭殑鍊煎皬浜庤繖涓侀紶鐨勫乏绔偣鍊兼椂錛屽氨浜ゆ崲錛岀洿鍒伴亣鍒頒竴涓┖媧炪傚鏋滄弧浜嗙殑璇濆氨鍚戝悗閬嶅巻錛岄亣鍒板彸绔偣澶т簬榪欎釜鑰侀紶鐨勫彸绔偣鏃訛紝灝變氦鎹紝鐩村埌閬囧埌涓涓┖媧炪傞亶鍘嗙殑鏃跺欒鏃跺埢鍒ゆ柇K鐨勫鹼紝濡傛灉鍒拌揪涓嶄簡閭ｄ釜鑼冨洿錛屽氨澧炲ぇK鐨勫箋?br />
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef struct
{
int s,t;
}ract;
ract r[503];
int line[503];
bool cmp(ract r1,ract r2)
{
if(r1.s==r2.s) return r1.t<r2.t;
return r1.s<r2.s;
}
int main()
{
int t,pos=0;
scanf("%d",&t);
while(t--)
{
memset(line,-1,sizeof(line));
int n;
scanf("%d",&n);
for(int i=0;i<n;++i)
{
scanf("%d %d",&r[i].s,&r[i].t);
}
sort(r,r+n,cmp);
int k=0;
for(int i=0;i<n;++i)
{
if(line[r[i].t]==-1)//濡傛灉鍙崇鐐圭殑媧炴槸絀虹殑
{
line[r[i].t]=i;
}
else
{
int flag=0,temp=i;
if(r[i].t>1)
for(int j=r[i].t-1;j>=1;--j)//鍚戝墠閬嶅巻錛屾槸鍚﹀凡浣忔弧
{
if(line[j]==-1) {flag=1;break;}
}
if(flag==1)
for(int j=r[i].t;j>=1;--j)//濡傛灉娌℃湁浣忔弧灝卞悜鍓嶉亶鍘?/span>
{
if(line[j]==-1)//閬囧埌絀烘礊灝變綇涓?/span>
{
line[j]=temp;
if(r[temp].s>j)
k=max(k,r[temp].s-j);//鏇存柊K鍊?/span>
break;
}
else if(r[line[j]].s<r[temp].s)//濡傛灉褰撳墠媧炰腑鐨勮侀紶鐨勫乏绔偣灝忎簬縐誨姩鐨勮侀紶鐨勫乏绔偣錛屽氨浜ゆ崲
{
int tmp2=line[j];
line[j]=temp;
if(r[temp].s>j)
k=max(k,r[temp].s-j);
temp=tmp2;
}
}
else
{
for(int j=r[i].t;j<=n;++j)//濡傛灉宸茬粡浣忔弧灝卞悜鍚庨亶鍘?/span>
{
if(line[j]==-1)
{
line[j]=temp;
if(r[temp].t<j)
k=max(k,j-r[temp].t);
break;
}
else
{
if(r[line[j]].t>r[temp].t)
{
int tmp2=line[j];
line[j]=temp;
if(r[temp].t<j)
k=max(k,j-r[temp].t);
temp=tmp2;
}
}
}
}
}
}
printf("Case #%d: %d\n",++pos,k);
}
return 0;
}
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef struct
{
int s,t;
}ract;
ract r[503];
int line[503];
bool cmp(ract r1,ract r2)
{
if(r1.s==r2.s) return r1.t<r2.t;
return r1.s<r2.s;
}
int main()
{
int t,pos=0;
scanf("%d",&t);
while(t--)
{
memset(line,-1,sizeof(line));
int n;
scanf("%d",&n);
for(int i=0;i<n;++i)
{
scanf("%d %d",&r[i].s,&r[i].t);
}
sort(r,r+n,cmp);
int k=0;
for(int i=0;i<n;++i)
{
if(line[r[i].t]==-1)//濡傛灉鍙崇鐐圭殑媧炴槸絀虹殑
{
line[r[i].t]=i;
}
else
{
int flag=0,temp=i;
if(r[i].t>1)
for(int j=r[i].t-1;j>=1;--j)//鍚戝墠閬嶅巻錛屾槸鍚﹀凡浣忔弧
{
if(line[j]==-1) {flag=1;break;}
}
if(flag==1)
for(int j=r[i].t;j>=1;--j)//濡傛灉娌℃湁浣忔弧灝卞悜鍓嶉亶鍘?/span>
{
if(line[j]==-1)//閬囧埌絀烘礊灝變綇涓?/span>
{
line[j]=temp;
if(r[temp].s>j)
k=max(k,r[temp].s-j);//鏇存柊K鍊?/span>
break;
}
else if(r[line[j]].s<r[temp].s)//濡傛灉褰撳墠媧炰腑鐨勮侀紶鐨勫乏绔偣灝忎簬縐誨姩鐨勮侀紶鐨勫乏绔偣錛屽氨浜ゆ崲
{
int tmp2=line[j];
line[j]=temp;
if(r[temp].s>j)
k=max(k,r[temp].s-j);
temp=tmp2;
}
}
else
{
for(int j=r[i].t;j<=n;++j)//濡傛灉宸茬粡浣忔弧灝卞悜鍚庨亶鍘?/span>
{
if(line[j]==-1)
{
line[j]=temp;
if(r[temp].t<j)
k=max(k,j-r[temp].t);
break;
}
else
{
if(r[line[j]].t>r[temp].t)
{
int tmp2=line[j];
line[j]=temp;
if(r[temp].t<j)
k=max(k,j-r[temp].t);
temp=tmp2;
}
}
}
}
}
}
printf("Case #%d: %d\n",++pos,k);
}
return 0;
}
]]>
// trietree.cpp : 瀹氫箟鎺у埗鍙板簲鐢ㄧ▼搴忕殑鍏ュ彛鐐廣?br />//
#include<cstdio>
#include<iostream>
#include<string.h>
using namespace std;
const int num_chars = 26; //鍏抽敭鐮佹渶澶т綅
int _max;
char ans[12];
class Trie
{
public:
Trie();
Trie(Trie& tr);
virtual ~Trie();
//int trie_search(const char* word, char*entry) const;
bool insert(const char* word);
protected:
struct Trie_node //鍏抽敭鐮佺被鍨?/span>
{
bool isfin;
int cnt; //鍏抽敭鐮佸綋鍓嶄綅鏁?/span>
Trie_node* branch[num_chars]; //鍏抽敭鐮佸瓨鏀炬暟緇?/span>
Trie_node();
};
Trie_node* root;
};
Trie::Trie_node::Trie_node() //緇撶偣瀹氫箟
{
isfin = false;
cnt = 0;
for(int i = 0; i < num_chars;++i)
branch[i] = NULL;
}
Trie::Trie():root(NULL)
{
}
Trie::~Trie()
{
}
bool Trie::insert(const char*word)
{
int result = 1,position = 0;
if(root == NULL)
root = new Trie_node;
char char_code;
Trie_node *location = root;
while(location != NULL && *word != 0)
{
if(*word >= 'a'&& *word <= 'z')
char_code = *word - 'a';
if(location->branch[char_code] == NULL)
location->branch[char_code] = new Trie_node;
location = location->branch[char_code];
position++;
word++;
}
++location->cnt;
if(location->cnt>_max)
{
_max=location->cnt;
return true;
}
else
return false;
}
int main()
{
Trie t;
int n;
while(scanf("%d",&n)!=EOF)
{
_max=0;
char s[12];
for(int i=0;i<n;++i)
{
scanf("%s",s);
if(t.insert(s))
{
strcpy(ans,s);
}
}
printf("%s %d\n",ans,_max);
}
return 0;
}
#include<cstdio>
#include<iostream>
#include<string.h>
using namespace std;
const int num_chars = 26; //鍏抽敭鐮佹渶澶т綅
int _max;
char ans[12];
class Trie
{
public:
Trie();
Trie(Trie& tr);
virtual ~Trie();
//int trie_search(const char* word, char*entry) const;
bool insert(const char* word);
protected:
struct Trie_node //鍏抽敭鐮佺被鍨?/span>
{
bool isfin;
int cnt; //鍏抽敭鐮佸綋鍓嶄綅鏁?/span>
Trie_node* branch[num_chars]; //鍏抽敭鐮佸瓨鏀炬暟緇?/span>
Trie_node();
};
Trie_node* root;
};
Trie::Trie_node::Trie_node() //緇撶偣瀹氫箟
{
isfin = false;
cnt = 0;
for(int i = 0; i < num_chars;++i)
branch[i] = NULL;
}
Trie::Trie():root(NULL)
{
}
Trie::~Trie()
{
}
bool Trie::insert(const char*word)
{
int result = 1,position = 0;
if(root == NULL)
root = new Trie_node;
char char_code;
Trie_node *location = root;
while(location != NULL && *word != 0)
{
if(*word >= 'a'&& *word <= 'z')
char_code = *word - 'a';
if(location->branch[char_code] == NULL)
location->branch[char_code] = new Trie_node;
location = location->branch[char_code];
position++;
word++;
}
++location->cnt;
if(location->cnt>_max)
{
_max=location->cnt;
return true;
}
else
return false;
}
int main()
{
Trie t;
int n;
while(scanf("%d",&n)!=EOF)
{
_max=0;
char s[12];
for(int i=0;i<n;++i)
{
scanf("%s",s);
if(t.insert(s))
{
strcpy(ans,s);
}
}
printf("%s %d\n",ans,_max);
}
return 0;
}
]]>
榪欓亾棰樻湁涓ょ瑙ｆ硶錛?/span>
絎竴縐嶏細姹?/span>s鍜?/span>~s鐨?/span>LCS錛岀劧鍚庡鐢ㄥ叕寮?/span>length-LCS闀垮害 鍗充負鎵姹傘?/span>
絎簩縐嶏細鐩存帴DP姹傝В銆?/span>
褰?/span>s[i] == s[j]鏃?/span>
榪欎釜棰樻垜鐢ㄧ殑鏄竴涓ぇ鍨嬬殑浜岀淮鏁扮粍錛屼唬鐮佸緢姘達紝涓嶅緩璁璧忋?/span>
#include<iostream>
#include<string>
#include<cstring>
#include<cstdio>
using namespace std;
const int MAXM=1001;
short int f[MAXM][MAXM];
char s[1001];
int LCS()
{
scanf("%s",s);
memset(f,0,sizeof(f));
int len=strlen(s);
for(int i=0;i<len;++i)
{
for(int j=i;j>=0;--j)
{
if(s[i]==s[j])
{
f[i+1][j+1]=f[i][j+2];
}
else
{
f[i+1][j+1]=min(f[i][j+1],f[i+1][j+2])+1;
}
}
}
return f[len][1];
}
int main()
{
int n;
cin>>n;
while(n--)
{
printf("%d\n",LCS());
}
return 0;
}
#include<string>
#include<cstring>
#include<cstdio>
using namespace std;
const int MAXM=1001;
short int f[MAXM][MAXM];
char s[1001];
int LCS()
{
scanf("%s",s);
memset(f,0,sizeof(f));
int len=strlen(s);
for(int i=0;i<len;++i)
{
for(int j=i;j>=0;--j)
{
if(s[i]==s[j])
{
f[i+1][j+1]=f[i][j+2];
}
else
{
f[i+1][j+1]=min(f[i][j+1],f[i+1][j+2])+1;
}
}
}
return f[len][1];
}
int main()
{
int n;
cin>>n;
while(n--)
{
printf("%d\n",LCS());
}
return 0;
}
]]>
棰樻剰錛氬棣嗘湁涓彲浠ヤ幾緙╃殑闂紝姣忕閽熷彲浠ヤ幾闀?/span>1涓崟浣嶏紝鎴栬呯緝灝?/span>1涓崟浣嶏紝鎴栬呭師鍦頒笉鍔ㄣ傛湁N涓己鐩楋紝姣忎釜寮虹洍浼氬湪t鐨勬椂闂村唴鍒拌揪騫舵寜錛屽鏋滄鏃墮棬鐨勫紑鏂瑰害鍜屼粬鐨勮韓鏉?/span>s姝ｅソ鐩哥瓑錛岃繖涓己鐩楀氨浼氳繘鏉ワ紝鐒跺悗浣犲氨鑳藉緱鍒?/span>p鐨勫姞鍒嗐?/span>
鍒濆鐘舵侀棬鏄叧闂殑錛岃浣犳眰鍑哄湪t鏃跺埢寰楀埌鐨勬渶澶у緱鍒嗐?/span>
鍒嗘瀽錛氭寜鏃墮棿浠庡皬鍒板ぇ鎺掑簭錛?/span>t鏃墮棿鍐呮渶澶х殑寰楀垎鐢?/span>t涔嬪墠鐨勬椂鍒誨喅瀹氾紝婊¤凍鏃犲悗鏁堟э紝姣忎竴涓椂鍒婚兘鑳藉緱鍒版渶浼樿В錛屾弧瓚蟲渶鏈夊瓙緇撴瀯錛屾墍浠?/span>DP銆?/span>
F[i]琛ㄧず絎?/span>i涓漢銆?/span>
褰撹韓鏉愪箣宸皬浜庢椂闂翠箣宸椂F[i]=max(f[i],f[j]+ple[i].p) 0<=j<i 浣嗗緱婊¤凍涓涓潯浠訛紝絎?/span>j涓漢宸茬粡榪涘幓錛屽惁鍒欓棬浼擱暱鐨勫搴﹀彲鑳戒細灝忎簬韜潗銆?br />#include<iostream>
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
const int MAXM=103;
typedef struct People
{
int t,p,s;
}People;
People ple[MAXM];
int f[MAXM];
bool cmp(People p1,People p2)
{
return p1.t<p2.t;
}
int main()
{
int n,k,s;
scanf("%d %d %d",&n,&k,&s);
for(int i=1;i<=n;++i)
scanf("%d",&ple[i].t);
for(int i=1;i<=n;++i)
scanf("%d",&ple[i].p);
for(int i=1;i<=n;++i)
scanf("%d",&ple[i].s);
sort(ple+1,ple+n+1,cmp);
f[0]=0;
ple[0].p=0;ple[0].s=0;ple[0].t=0;
int ans=0;
for(int i=1;i<=n;++i)
{
for(int j=i-1;j>=0;--j)
{
if(f[j]>=ple[j].p)//涓嬩竴姝ュ仛宸殑鍩虹鏄j涓漢宸茬粡榪涘幓銆?/span>
if(abs(ple[i].s-ple[j].s)<=ple[i].t-ple[j].t)
f[i]=max(f[i],f[j]+ple[i].p);
}
ans=max(ans,f[i]);
}
printf("%d\n",ans);
return 0;
}
]]>
姣旇禌鐨勬椂鍊欐墜鍐欑殑浜屽垎錛屾繪槸RE銆傝竟鐣屽鐞嗙殑鑳藉姏榪樻湁寰呭姞寮恒?/span>
鐪嬩簡瑙ｉ鎶ュ憡涔嬪悗鎰熻鑷繁寮辯垎浜嗭紝鐭ラ亾鏂規硶鐨勯閮藉啓涓嶅嚭鏉ャ傝屼笖褰撴椂榪樻槸鐢ㄧ殑map鍐欑殑錛屾偛鍓х殑瓚呮椂浜嗐傛敼鐢?/span>vector灝辮繃浜嗐?/span>
鎶婃瘡涓暟瀛楀嚭鐜扮殑浣嶇疆瀛樺偍涓嬫潵錛岀劧鍚庡鎵姹傜殑浣嶇疆榪涜涓ゆ浜屽垎錛屽氨OK浜嗐傜敤鐨勬槸stl閲岀殑浜屽垎錛屾病鎯沖埌榪唬鍣ㄨ繕鍙互榪欐牱鐢ㄣ?br />
#include<iostream>
#include<cstdio>
#include<cstring>
#include<map>
#include<algorithm>
#include<vector>
using namespace std;
vector<int> m[100003];
int main()
{
int n,q;
while(scanf("%d %d",&n,&q)!=EOF)
{
for(int i=0;i<100003;++i)
m[i].clear();
int val,l,r,x;
for(int i=1;i<=n;++i)
{
scanf("%d",&val);
m[val].push_back(i);
}
for(int i=1;i<=q;i++)
{
scanf("%d %d %d",&l,&r,&x);
if(m[x].size()!=0)
if( *(--m[x].end())<l || *m[x].begin()>r )
printf("0\n");
else
{
int ans=( (--upper_bound(m[x].begin(),m[x].end(),r))-m[x].begin() )-( lower_bound(m[x].begin(),m[x].end(),l)-m[x].begin() )+1;
printf("%d\n",ans);
}
else printf("0\n");
}
}
return 0;
}
#include<cstdio>
#include<cstring>
#include<map>
#include<algorithm>
#include<vector>
using namespace std;
vector<int> m[100003];
int main()
{
int n,q;
while(scanf("%d %d",&n,&q)!=EOF)
{
for(int i=0;i<100003;++i)
m[i].clear();
int val,l,r,x;
for(int i=1;i<=n;++i)
{
scanf("%d",&val);
m[val].push_back(i);
}
for(int i=1;i<=q;i++)
{
scanf("%d %d %d",&l,&r,&x);
if(m[x].size()!=0)
if( *(--m[x].end())<l || *m[x].begin()>r )
printf("0\n");
else
{
int ans=( (--upper_bound(m[x].begin(),m[x].end(),r))-m[x].begin() )-( lower_bound(m[x].begin(),m[x].end(),l)-m[x].begin() )+1;
printf("%d\n",ans);
}
else printf("0\n");
}
}
return 0;
}
]]>
]]>
澶ф剰錛氫袱涓瀭鐩翠簬x杞寸殑鐩寸嚎lx鍜?/span>rx鍥存垚鐨勫尯鍩熴傛湁n鏉＄洿綰跨┛榪囪繖鐗囧尯鍩燂紝姣忔潯鐩寸嚎yi=kxi+b錛岀粰鍑?/span>k鍜?/span>b銆傛眰鐩寸嚎鎶婅繖涓尯鍩熷垎鎴愪簡鍑犱釜閮ㄥ垎銆備笁鏉＄洿綰夸笉浼氫氦浜庝竴鐐癸紙鍖呮嫭錛氫袱涓瀭鐩翠簬x杞寸殑鐩寸嚎錛夈?/span>
鐢誨浘鍙互鎵懼嚭涓縐嶅叧緋伙紝鍒嗘垚鐨勫尯鍩熸暟=浜ょ偣鏁?/span>+綰挎鏁?/span>+1錛涘宸︾鐐逛粠澶у埌灝忔帓搴忥紝鐒跺悗瀵瑰彸绔偣姹傞嗗簭鏁幫紝閫嗗簭鏁板氨鏄氦鐐規暟錛岀嚎孌墊暟宸茬煡錛岀┖闂存暟灝卞嚭鏉ヤ簡銆?/span>
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
const int MAXM=30004;
const int INF=0x7fffffff-1;
typedef struct
{
int y1,y2;
}Line;
Line line[MAXM];
int temp1[MAXM/2+1];
int temp2[MAXM/2+1];
int cnt;
bool cmp(Line l1,Line l2)
{
return l1.y1>l2.y1;
}
void merge(int start,int mid,int end)
{
int n1,n2;
n1=mid-start+1;
n2=end-mid;
for(int i=0;i<n1;i++)
temp1[i]=line[start+i].y2;
for(int i=0;i<n2;i++)
temp2[i]=line[mid+i+1].y2;
temp1[n1]=-INF;
temp2[n2]=-INF;
for(int k=start,i=0,j=0;k<=end;k++)
{
if(temp1[i]>=temp2[j])
{
line[k].y2=temp1[i];
i++;
}
else
{
cnt+=n1-i;//姹傞嗗簭鏁?/span>
line[k].y2=temp2[j];
j++;
}
}
}
//褰掑茍鎺掑簭
void mergesort(int start,int end)
{
if(start>=end) return;
int mid=(end+start)/2;
mergesort(start,mid);
mergesort(mid+1,end);
merge(start,mid,end);
}
int main()
{
int lx,rx;
while(scanf("%d%d",&lx,&rx)!=EOF)
{
cnt=0;
int n,k,b;
scanf("%d",&n);
for(int i=0;i<n;i++)
{
scanf("%d%d",&k,&b);
line[i].y1=lx*k+b;
line[i].y2=rx*k+b;
}
sort(line,line+n,cmp);//瀵瑰乏绔偣浠庡ぇ鍒板皬鎺掑簭
mergesort(0,n-1);
printf("%d\n",cnt+n+1);//絀洪棿鏁?浜ょ偣鏁?綰挎鏁?1
}
return 0;
}
#include<cstdio>
#include<algorithm>
using namespace std;
const int MAXM=30004;
const int INF=0x7fffffff-1;
typedef struct
{
int y1,y2;
}Line;
Line line[MAXM];
int temp1[MAXM/2+1];
int temp2[MAXM/2+1];
int cnt;
bool cmp(Line l1,Line l2)
{
return l1.y1>l2.y1;
}
void merge(int start,int mid,int end)
{
int n1,n2;
n1=mid-start+1;
n2=end-mid;
for(int i=0;i<n1;i++)
temp1[i]=line[start+i].y2;
for(int i=0;i<n2;i++)
temp2[i]=line[mid+i+1].y2;
temp1[n1]=-INF;
temp2[n2]=-INF;
for(int k=start,i=0,j=0;k<=end;k++)
{
if(temp1[i]>=temp2[j])
{
line[k].y2=temp1[i];
i++;
}
else
{
cnt+=n1-i;//姹傞嗗簭鏁?/span>
line[k].y2=temp2[j];
j++;
}
}
}
//褰掑茍鎺掑簭
void mergesort(int start,int end)
{
if(start>=end) return;
int mid=(end+start)/2;
mergesort(start,mid);
mergesort(mid+1,end);
merge(start,mid,end);
}
int main()
{
int lx,rx;
while(scanf("%d%d",&lx,&rx)!=EOF)
{
cnt=0;
int n,k,b;
scanf("%d",&n);
for(int i=0;i<n;i++)
{
scanf("%d%d",&k,&b);
line[i].y1=lx*k+b;
line[i].y2=rx*k+b;
}
sort(line,line+n,cmp);//瀵瑰乏绔偣浠庡ぇ鍒板皬鎺掑簭
mergesort(0,n-1);
printf("%d\n",cnt+n+1);//絀洪棿鏁?浜ょ偣鏁?綰挎鏁?1
}
return 0;
}
]]>
涓鐩磋涓烘槸浜岀淮綰挎鏍戯紝鐪嬩簡瑙ｉ鎶ュ憡鍚庡眳鐒舵槸姘撮銆?/span>
鏈澶?/span>1000涓煩褰€傛瘡嬈℃壂鎻忕煩褰笌涔嬪墠鐨勭煩褰㈡槸鍚︾浉浜わ紝鍦ㄧ浉浜ょ殑鐭╁艦涓壘鍒頒竴涓渶澶х殑鍊?/span>max錛岃榪欎釜max鍔犱笂h灝辨槸榪欐鐭╁艦鐨勫箋傛瘡嬈″悜鍥炴壂鎻忎竴閬嶏紝鏈楂樹篃灝?/span>1000*1000鐨勬椂闂達紝1s鍐呯粷瀵規病闂銆?br />#include<iostream>
#include<cstdio>
using namespace std;
typedef struct
{
int x1,y1,x2,y2,_max;
}Matrix;
Matrix matrix[1003];
bool cover(int i,int j)//鏄惁鐩鎬氦
{
if(matrix[i].x1>=matrix[j].x2||matrix[j].x1>=matrix[i].x2) return false;
if(matrix[i].y1>=matrix[j].y2||matrix[j].y1>=matrix[i].y2) return false;
return true;
}
int main()
{
int N,M,C;
while(scanf("%d %d %d",&N,&M,&C)!=EOF)
{
int ans=0;
int a,b,h,x,y;
for(int i=0;i<C;i++)
{
int tmax=0;
scanf("%d %d %d %d %d",&a,&b,&h,&x,&y);
matrix[i].x1=x;
matrix[i].y1=y;
matrix[i].x2=x+a;
matrix[i].y2=y+b;
for(int j=i-1;j>=0;j--)
{
if(cover(i,j))
{
tmax=max(tmax,matrix[j]._max);
}
}
matrix[i]._max=tmax+h;
ans=max(ans,matrix[i]._max);
}
printf("%d\n",ans);
}
return 0;
}
]]>
#include<iostream>
#include<cstdio>
using namespace std;
bool comp(int x,int y,int k)
{
int temp1,temp2;
while(y!=0)
{
temp1=y%k;
y/=k;
while(x!=0)
{
temp2=x%k;
if(temp1==temp2)
break;
x/=k;
}
if(x==0) return false;
x/=k;
}
return true;
}
int main()
{
int x,y;
scanf("%d %d",&x,&y);
int k=2;
for(;k<=x;k++)
{
if(comp(x,y,k)) break;
}
if(k>x) printf("No solution\n");
else printf("%d\n",k);
return 0;
}
#include<cstdio>
using namespace std;
bool comp(int x,int y,int k)
{
int temp1,temp2;
while(y!=0)
{
temp1=y%k;
y/=k;
while(x!=0)
{
temp2=x%k;
if(temp1==temp2)
break;
x/=k;
}
if(x==0) return false;
x/=k;
}
return true;
}
int main()
{
int x,y;
scanf("%d %d",&x,&y);
int k=2;
for(;k<=x;k++)
{
if(comp(x,y,k)) break;
}
if(k>x) printf("No solution\n");
else printf("%d\n",k);
return 0;
}
]]>
姘撮銆?/span>
棰樻剰錛氱粰浣犳瘡澶╃殑鑲′環錛岃浣犳壘鍑烘渶灝忕殑K1涓偂浠鳳紝鐒跺悗鎸夋棩鏈熶粠灝忓埌澶ф帓搴忚緭鍑猴紝鎵懼嚭鏈澶х殑k2涓偂浠鳳紝鎸夋棩鏈熶粠澶у埌灝忚緭鍑恒?/span>
鎴戠敤浜?/span>4涓?/span>sort銆?br />
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
typedef struct
{
int p,d;
}Data;
Data dt[1000003];
bool cmp1(Data d1,Data d2)
{
if(d1.p==d2.p) return d1.d<d2.d;
return d1.p<d2.p;
}
bool cmp2(Data d1,Data d2)
{
if(d1.p==d2.p) return d1.d>d2.d;
return d1.p>d2.p;
}
bool cmp3(Data d1,Data d2)
{
return d1.d<d2.d;
}
bool cmp4(Data d1,Data d2)
{
return d1.d>d2.d;
}
void print()
{
static int cnt=0;
printf("Case %d\n",++cnt);
}
int main()
{
int n,k1,k2;
while(scanf("%d %d %d",&n,&k1,&k2),n&&k1&&k2)
{
for(int i=0;i<n;i++)
{
scanf("%d",&dt[i].p);
dt[i].d=i+1;
}
sort(dt,dt+n,cmp1);//浠庡皬鍒板ぇ鎺掑簭
print();//蹇界暐
sort(dt,dt+k1,cmp3);//鏃ユ湡鐨勫瓧鍏稿簭浠庡皬鍒板ぇ
printf("%d",dt[0].d);
for(int i=1;i<k1;i++)
printf(" %d",dt[i].d);
printf("\n");
sort(dt,dt+n,cmp2);//浠庡ぇ鍒板皬鎺掑簭
sort(dt,dt+k2,cmp4);//鏃ユ湡鐨勫瓧鍏稿簭浠庡ぇ鍒板皬
printf("%d",dt[0].d);
for(int i=1;i<k2;i++)
printf(" %d",dt[i].d);
printf("\n");
}
return 0;
}
#include<cstdio>
#include<algorithm>
using namespace std;
typedef struct
{
int p,d;
}Data;
Data dt[1000003];
bool cmp1(Data d1,Data d2)
{
if(d1.p==d2.p) return d1.d<d2.d;
return d1.p<d2.p;
}
bool cmp2(Data d1,Data d2)
{
if(d1.p==d2.p) return d1.d>d2.d;
return d1.p>d2.p;
}
bool cmp3(Data d1,Data d2)
{
return d1.d<d2.d;
}
bool cmp4(Data d1,Data d2)
{
return d1.d>d2.d;
}
void print()
{
static int cnt=0;
printf("Case %d\n",++cnt);
}
int main()
{
int n,k1,k2;
while(scanf("%d %d %d",&n,&k1,&k2),n&&k1&&k2)
{
for(int i=0;i<n;i++)
{
scanf("%d",&dt[i].p);
dt[i].d=i+1;
}
sort(dt,dt+n,cmp1);//浠庡皬鍒板ぇ鎺掑簭
print();//蹇界暐
sort(dt,dt+k1,cmp3);//鏃ユ湡鐨勫瓧鍏稿簭浠庡皬鍒板ぇ
printf("%d",dt[0].d);
for(int i=1;i<k1;i++)
printf(" %d",dt[i].d);
printf("\n");
sort(dt,dt+n,cmp2);//浠庡ぇ鍒板皬鎺掑簭
sort(dt,dt+k2,cmp4);//鏃ユ湡鐨勫瓧鍏稿簭浠庡ぇ鍒板皬
printf("%d",dt[0].d);
for(int i=1;i<k2;i++)
printf(" %d",dt[i].d);
printf("\n");
}
return 0;
}
]]>
DP鎴栧崱鐗瑰叞鏁?span style="font-family:瀹嬩綋;">銆?/span>
寮辯垎浜嗐傚仛棰樼殑鏃跺欏彧鎯崇潃鐢ㄤ竴涓姸鎬佸幓鍋氾紝緇撴灉鎮插墽浜嗐傚悗鏉ユ垚鍝ユ彁閱掔敤浜岀淮鐨勶紝鎴戞墠鍙戠幇寰楃敤涓や釜鐘舵佸幓鍐欍傚搸錛屾庝箞娌℃兂鍒頒袱涓姸鎬佸憿銆?br />棰樻剰錛氬湪涓涓摱瀛愰噷鏈塏鐗囪嵂錛屾瘡嬈″悆鍗婄墖錛屼粠鐡跺瓙閲屽彲鑳芥嬁鍑烘暣鐗囷紝涔熷彲鑳芥嬁鍑哄崐鐗囷紝濡傛灉鎷垮嚭鏁寸墖錛岃涓篧錛屽崐鐗囪涓篐銆傞棶鏈夊灝戠鎺掑垪銆?/span>
絎竴涓姸鎬侊細瀹屾暣鑽墖鐨勬暟閲忋傜浜屼釜鐘舵侊細鍗婄墖鑽墖鐨勬暟閲忋?/span>
F錛?/span>i錛?/span>j錛?/span>=f錛?/span>i-1,j+1錛?/span>+f錛?/span>I錛?/span>j-1錛夛紱
褰撳悆鐨勬槸鏁寸墖鏃訛紝i-1錛屽崐鐗囩殑澧炲姞涓涓紝j+1銆?/span>
褰撳悆鐨勬槸鍗婄墖鏃訛紝i涓嶅彉錛?/span>j-1銆?/span>
鐢ㄤ袱涓姸鎬佸啓鐨勬椂鍊欒繖涓灝卞緢姘翠簡銆備笉榪囨彁浜ょ殑鏃跺欏湪g++涓嬬敤lang lang WA錛屾敼鎴?/span>int64鍦?/span>C++涓嬫彁浜ゅ氨AC浜嗐傚緢鏄笉瑙ｃ?br />
鍗＄壒鍏版暟鐨勬柟娉曞氨涓嶅璇翠簡銆傘傘傘備綘鎳傜殑銆傘?/span>
#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
__int64 f[33][33];
int main()
{
memset(f,0,sizeof(f));
int k=30;
for(int i=0;i<k;i++) f[1][i]=i+1;
for(int i=2;i<=30;i++)
{
k--;
f[i][0]=f[i-1][1];
for(int j=1;j<k;j++)
{
f[i][j]=f[i][j-1]+f[i-1][j+1];
}
}
int s;
while(scanf("%d",&s),s)
{
printf("%I64d\n",f[s][0]);
}
return 0;
}
#include<cstring>
#include<cstdio>
using namespace std;
__int64 f[33][33];
int main()
{
memset(f,0,sizeof(f));
int k=30;
for(int i=0;i<k;i++) f[1][i]=i+1;
for(int i=2;i<=30;i++)
{
k--;
f[i][0]=f[i-1][1];
for(int j=1;j<k;j++)
{
f[i][j]=f[i][j-1]+f[i-1][j+1];
}
}
int s;
while(scanf("%d",&s),s)
{
printf("%I64d\n",f[s][0]);
}
return 0;
}
]]>
棰樼湅涓嶆噦錛屽湪緗戜笂鎵懼埌鐨勭炕璇戙傚氨鏄暣涓覆錛堜笉鏄暣琛岋級鐨勭害鐟熷か鐜?br />
#include<iostream>
#include<cstdio>
using namespace std;
char str[30003];
int Josephus(int n,int m,int k ) //鍒嗗埆涓猴細浜烘暟錛屽嚭鍦堟闀匡紝璧蜂嬌鎶ユ暟浣嶇疆,
{
int x=1;
if (m == 1)
k = k == 1 ? n : (k + n - 1) % n;
else{
for (int i = 1; i <= n; i++)
{
if ((k + m) < i)
{
x = (i - k + 1) / (m - 1) - 1;
if (i + x < n){
i = i + x;
k = (k + m * x);
}
else{
k = k + m * (n - i) ;
i = n;
}
}
k = (k + m - 1) % i + 1;
}
}
return k; //榪斿洖鏈鍚庝竴浜虹殑浣嶇疆
}
int main()
{
//freopen("in.txt","r",stdin);
int len=0;
while(scanf("%c",&str[0])!=EOF)
{
if(str[0]>=' ')
str[++len]=str[0];
}
int k=Josephus(len,1999,1);
if (str[k]=='?')
printf("Yes\n");
else if (str[k]==' ')
printf("No\n");
else
printf("No comments\n");
return 0;
}
#include<cstdio>
using namespace std;
char str[30003];
int Josephus(int n,int m,int k ) //鍒嗗埆涓猴細浜烘暟錛屽嚭鍦堟闀匡紝璧蜂嬌鎶ユ暟浣嶇疆,
{
int x=1;
if (m == 1)
k = k == 1 ? n : (k + n - 1) % n;
else{
for (int i = 1; i <= n; i++)
{
if ((k + m) < i)
{
x = (i - k + 1) / (m - 1) - 1;
if (i + x < n){
i = i + x;
k = (k + m * x);
}
else{
k = k + m * (n - i) ;
i = n;
}
}
k = (k + m - 1) % i + 1;
}
}
return k; //榪斿洖鏈鍚庝竴浜虹殑浣嶇疆
}
int main()
{
//freopen("in.txt","r",stdin);
int len=0;
while(scanf("%c",&str[0])!=EOF)
{
if(str[0]>=' ')
str[++len]=str[0];
}
int k=Josephus(len,1999,1);
if (str[k]=='?')
printf("Yes\n");
else if (str[k]==' ')
printf("No\n");
else
printf("No comments\n");
return 0;
}
]]>
棰樼洰淇濊瘉鑷沖皯鏈変竴涓?/span>1銆?/span>2銆?/span>3銆?/span>4銆傝鏄庤繖鍥涗釜鏁版槸涓涓獊鐮寸偣銆傜敱姝ゅ彲浠ヨ仈鎯沖埌浠?/span>1銆?/span>2銆?/span>3銆?/span>4鍥涗釜鏁板瓧緇撳熬鐨勬暟淇濊瘉鑳借7鏁撮櫎銆傝繖鏍蜂笉璁哄墠杈圭殑鏁版庢牱鎺掑垪錛屽悗杈瑰洓涓暟鎬繪湁涓縐嶇粍鍚堣兘澶熶繚璇佹暣浣撳彲浠ヨ7鏁撮櫎銆?br />
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int z[7]={4123,1324,1234,2341,1243,3421,3142};
char s[23];
int ns[23];
int num0_9[10];
int atoi(char s)
{
return s-'0';
}
int fun(int x,int num)//鎶婂墠杈圭殑鏁版帓鍒楁垚鏂版暟
{
for(int i=0;i<num0_9[num];i++)
{
ns[x+i]=num;
}
return x+num0_9[num];
}
int fun2(int x)//姹傚墠杈圭殑鏁伴櫎浠?鐨勪綑鏁?/span>
{
int yu=0;
for(int i=0;i<x;i++)
{
yu=(yu*10+ns[i])%7;
}
return yu;
}
int main()
{
int t;
scanf("%d",&t);
while(t--)
{
memset(num0_9,0,sizeof(num0_9));
scanf("%s",s);
int slen=strlen(s);
//緇熻姣忎釜鏁扮殑涓暟
for(int i=0;i<slen;i++)
{
int num=atoi(s[i]);
num0_9[num]++;
}
//鍑忓幓1銆?銆?銆?
for(int i=1;i<=4;i++)
{
num0_9[i]--;
}
//姹傚墠杈圭粍鎴愮殑鏂版暟
int x=0;
for(int i=1;i<=9;i++)
{
x=fun(x,i);
}
int yu=fun2(x);//姹傛柊鏁伴櫎浠?鐨勪綑鏁?/span>
int i;
//鎵懼埌涓縐嶇粍鍚堝彲浠ヤ笌鍓嶈竟鐨勬暟緇勫悎璧鋒潵琚?鏁撮櫎
for(i=0;i<7;i++)
{
if((yu*10000+z[i])%7==0)
{
break;
}
}
//杈撳嚭錛屽悗杈瑰彲浠ヨˉ涓?
for(int j=0;j<x;j++)
printf("%d",ns[j]);
printf("%d",z[i]);
for(int j=0;j<num0_9[0];j++)
printf("0");
printf("\n");
}
return 0;
}
#include<cstdio>
#include<cstring>
using namespace std;
const int z[7]={4123,1324,1234,2341,1243,3421,3142};
char s[23];
int ns[23];
int num0_9[10];
int atoi(char s)
{
return s-'0';
}
int fun(int x,int num)//鎶婂墠杈圭殑鏁版帓鍒楁垚鏂版暟
{
for(int i=0;i<num0_9[num];i++)
{
ns[x+i]=num;
}
return x+num0_9[num];
}
int fun2(int x)//姹傚墠杈圭殑鏁伴櫎浠?鐨勪綑鏁?/span>
{
int yu=0;
for(int i=0;i<x;i++)
{
yu=(yu*10+ns[i])%7;
}
return yu;
}
int main()
{
int t;
scanf("%d",&t);
while(t--)
{
memset(num0_9,0,sizeof(num0_9));
scanf("%s",s);
int slen=strlen(s);
//緇熻姣忎釜鏁扮殑涓暟
for(int i=0;i<slen;i++)
{
int num=atoi(s[i]);
num0_9[num]++;
}
//鍑忓幓1銆?銆?銆?
for(int i=1;i<=4;i++)
{
num0_9[i]--;
}
//姹傚墠杈圭粍鎴愮殑鏂版暟
int x=0;
for(int i=1;i<=9;i++)
{
x=fun(x,i);
}
int yu=fun2(x);//姹傛柊鏁伴櫎浠?鐨勪綑鏁?/span>
int i;
//鎵懼埌涓縐嶇粍鍚堝彲浠ヤ笌鍓嶈竟鐨勬暟緇勫悎璧鋒潵琚?鏁撮櫎
for(i=0;i<7;i++)
{
if((yu*10000+z[i])%7==0)
{
break;
}
}
//杈撳嚭錛屽悗杈瑰彲浠ヨˉ涓?
for(int j=0;j<x;j++)
printf("%d",ns[j]);
printf("%d",z[i]);
for(int j=0;j<num0_9[0];j++)
printf("0");
printf("\n");
}
return 0;
}
]]>
綆鍗曟暟瀛︺?/span>
棰樻剰鏄粰瀹氶暱鍜屽錛屾眰瀵硅綰跨孩鑹插尯鍩熺殑闀垮害鍜屻?/span>
鎶?/span>m,n閮介櫎浠ヤ粬浠殑鏈澶у叕綰︽暟t錛屼嬌tm=m/t,tn=n/t錛屾柊tm錛?/span>tn鎵緇勬垚鐨勭煩褰㈢殑瀵硅綰塊暱搴?/span>*t灝辨槸鍘熺煩褰㈢殑瀵硅綰塊暱搴︺?/span>
鎶婂瑙掔嚎騫沖潎鍒嗘垚tm*tn鏉＄嚎孌碉紝瀵硅綰夸笌姣忔潯綰挎鐨勪氦鐐瑰繀鍦?/span>tm*tn浠戒腑鐨勭嚎孌電殑绔偣涓婏紙鍙埄鐢ㄧ浉浼間笁瑙掑艦璇佹槑錛岃繖閲岀渷鐣ワ級銆?/span>
瑙傚療鍙互鐪嬪嚭濡傛灉tm鍜?/span>tn鏈変竴涓槸鍋舵暟錛屽垯綰㈣壊綰挎鐨勬暟閲忓拰钃濊壊綰挎鐨勬暟閲忕浉絳夛紝濡傛灉tm鍜?/span>tn閮芥槸濂囨暟錛屽垯綰㈣壊綰挎鐨勬暟閲?/span>=钃濊壊綰挎鐨勬暟閲?/span>+1錛岃繖鏍鋒牴鎹瘮渚嬪氨鍙互姹傚嚭綰㈣壊綰挎鐨勯暱搴︿簡銆?br />
#include<iostream>
#include<cstdio>
#include<cmath>
using namespace std;
typedef long long ll;
ll gcd(ll m,ll n)
{
if(!n) return m;
return gcd(n,m%n);
}
int main()
{
ll m,n,tm,tn,t;
while(scanf("%lld %lld",&m,&n)!=EOF)
{
tm=m>n?m:n;
tn=m<n?m:n;
t=gcd(m,n);
tm/=t;
tn/=t;
if(tm%2==0||tn%2==0)
{
printf("%.3lf\n",sqrt((double)(tm*tm+tn*tn))/2*t);
continue;
}
double ans;
ans=sqrt((double)(tm*tm+tn*tn))*(tm*tn+1)/(2*tm*tn)*t;
printf("%.3lf\n",ans);
}
return 0;
}
#include<cstdio>
#include<cmath>
using namespace std;
typedef long long ll;
ll gcd(ll m,ll n)
{
if(!n) return m;
return gcd(n,m%n);
}
int main()
{
ll m,n,tm,tn,t;
while(scanf("%lld %lld",&m,&n)!=EOF)
{
tm=m>n?m:n;
tn=m<n?m:n;
t=gcd(m,n);
tm/=t;
tn/=t;
if(tm%2==0||tn%2==0)
{
printf("%.3lf\n",sqrt((double)(tm*tm+tn*tn))/2*t);
continue;
}
double ans;
ans=sqrt((double)(tm*tm+tn*tn))*(tm*tn+1)/(2*tm*tn)*t;
printf("%.3lf\n",ans);
}
return 0;
}
]]>
宸у鏁扮粍鎴栬呬竴緇寸嚎孌墊爲銆?br />姣旇禌鏃舵病鏈変粩緇嗙湅棰橈紝緇撴潫鏍囪鍐欓敊浜嗭紝瀵艱嚧TLE浜嗕袱嬈°傚ぇ鑷存剰鎬濇槸錛岀嚎孌墊爲闀垮害[0,len]錛屽垵濮嬪寲涓?/span>0錛屾彃鍏ュ尯闂村閲忥紝鏈鍚庢眰涓や釜鏈澶у肩殑浣嶇疆錛屼竴涓槸浠庡乏鍒板彸鐨勬渶澶у鹼紙閬囧埌鐨勭涓涓渶澶у煎嵆涓烘墍姹傦級錛屼竴涓槸浠庡彸鍒板乏鐨勬渶澶у箋?br />濂介暱鏃墮棿娌″啓綰挎鏍戠殑鍘熷洜錛屽鑷存垜鐩存帴涓婃ā鏉夸簡錛岀粨鏋勪綋鍙橀噺鏈夌偣澶氾紝鍐欑殑涓嶆槸寰堝ソ錛屼唬鐮佸緢闀褲傛寮忔瘮璧涗腑絎竴涓嚎孌墊爲銆?br />鍚庢潵鍚鏈塐錛坣錛夌殑綆楁硶錛岀獊鐒跺氨鎯寵搗鏉ヤ簡瀛︽牎oj涓婃湁涓閬撳閥濡欒繍鐢ㄦ暟緇勭殑棰橈紝鐒跺悗鎰熻鐢ㄦ暟緇勫彲浠ユ悶錛岃瘯浜嗕竴涓婣C鎺変簡錛屾椂闂?900+錛屾瘮綰挎鏍戠殑5000+灝戝浜嗐傘?br />銆?br />鏁扮粍浠ｇ爜錛?br />#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int MAXM=15003;
int a[MAXM];
int main()
{
int n;
while(scanf("%d",&n)!=EOF)
{
int l,r,b;
memset(a,0,sizeof(a));
while(scanf("%d %d %d",&l,&r,&b))
{
if(l==-1) break;
a[l]+=b;
a[r+1]-=b;
}
int lmax=a[0],posl=0;
for(int i=1;i<=n;i++)
{
a[i]+=a[i-1];
if(lmax<a[i])
{
lmax=a[i];
posl=i;
}
}
int posr;
for(int i=n;i>=0;i--)
{
if(a[i]==lmax)
{
posr=i;
break;
}
}
printf("%d %d\n",posl,posr);
}
return 0;
}
綰挎鏍戜唬鐮侊細
#include<iostream>
#include<cstdio>
using namespace std;
inline int L(int r){return r<<1;}
inline int R(int r){return (r<<1)+1;}
inline int MID(int l,int r){return (l+r)>>1;}
const int MAXN=15003;
typedef struct
{
int left,right;
int _max,posl,posr;
int add;
}Node;
Node tree[MAXN*4];
//int arr[MAXN];
void Create(int l,int r,int root)
{
tree[root].left=l;
tree[root].right=r;
if(l==r)
{
tree[root]._max=0;
tree[root].posl=l;
tree[root].posr=r;
tree[root].add=0;
return;
}
int mid=MID(l,r);
Create(l,mid,L(root));
Create(mid+1,r,R(root));
tree[root]._max=0;
tree[root].posl=l;
tree[root].posr=r;
tree[root].add=0;
}
void Update_info(int node)
{
if(tree[node].add)
{
tree[L(node)].add+=tree[node].add;//鏇存柊瀛愭爲鏃朵細鐢ㄥ埌
tree[R(node)].add+=tree[node].add;
tree[L(node)]._max+=tree[node].add;
tree[R(node)]._max+=tree[node].add;
tree[node].add=0;
}
}
void Updata(int l,int r,int val,int root)
{
if(l<=tree[root].left&&tree[root].right<=r)
{
tree[root].add+=val;
tree[root]._max+=val;
return;
}
Update_info(root);
if(tree[root].left==tree[root].right) return;
int mid=(tree[root].left+tree[root].right)>>1;
if(l>mid) Updata(l,r,val,(root<<1)+1);
else if(r<=mid) Updata(l,r,val,root<<1);
else
{
Updata(l,mid,val,root<<1);
Updata(mid+1,r,val,(root<<1)+1);
}
if(tree[L(root)]._max>tree[R(root)]._max)
{
tree[root]._max=tree[L(root)]._max;
tree[root].posl=tree[L(root)].posl;
tree[root].posr=tree[L(root)].posr;
}
else if(tree[L(root)]._max==tree[R(root)]._max)
{
tree[root]._max=tree[L(root)]._max;
tree[root].posl=tree[L(root)].posl;
tree[root].posr=tree[R(root)].posr;
}
else
{
tree[root]._max=tree[R(root)]._max;
tree[root].posl=tree[R(root)].posl;
tree[root].posr=tree[R(root)].posr;
}
}
int main()
{
int n;
while(scanf("%d",&n)!=EOF)
{
int l,r,b;
Create(0,n,1);
while(scanf("%d %d %d",&l,&r,&b))
{
if(l==-1) break;
Updata(l,r,b,1);
}
printf("%d %d\n",tree[1].posl,tree[1].posr);
}
return 0;
}
#include<cstdio>
using namespace std;
inline int L(int r){return r<<1;}
inline int R(int r){return (r<<1)+1;}
inline int MID(int l,int r){return (l+r)>>1;}
const int MAXN=15003;
typedef struct
{
int left,right;
int _max,posl,posr;
int add;
}Node;
Node tree[MAXN*4];
//int arr[MAXN];
void Create(int l,int r,int root)
{
tree[root].left=l;
tree[root].right=r;
if(l==r)
{
tree[root]._max=0;
tree[root].posl=l;
tree[root].posr=r;
tree[root].add=0;
return;
}
int mid=MID(l,r);
Create(l,mid,L(root));
Create(mid+1,r,R(root));
tree[root]._max=0;
tree[root].posl=l;
tree[root].posr=r;
tree[root].add=0;
}
void Update_info(int node)
{
if(tree[node].add)
{
tree[L(node)].add+=tree[node].add;//鏇存柊瀛愭爲鏃朵細鐢ㄥ埌
tree[R(node)].add+=tree[node].add;
tree[L(node)]._max+=tree[node].add;
tree[R(node)]._max+=tree[node].add;
tree[node].add=0;
}
}
void Updata(int l,int r,int val,int root)
{
if(l<=tree[root].left&&tree[root].right<=r)
{
tree[root].add+=val;
tree[root]._max+=val;
return;
}
Update_info(root);
if(tree[root].left==tree[root].right) return;
int mid=(tree[root].left+tree[root].right)>>1;
if(l>mid) Updata(l,r,val,(root<<1)+1);
else if(r<=mid) Updata(l,r,val,root<<1);
else
{
Updata(l,mid,val,root<<1);
Updata(mid+1,r,val,(root<<1)+1);
}
if(tree[L(root)]._max>tree[R(root)]._max)
{
tree[root]._max=tree[L(root)]._max;
tree[root].posl=tree[L(root)].posl;
tree[root].posr=tree[L(root)].posr;
}
else if(tree[L(root)]._max==tree[R(root)]._max)
{
tree[root]._max=tree[L(root)]._max;
tree[root].posl=tree[L(root)].posl;
tree[root].posr=tree[R(root)].posr;
}
else
{
tree[root]._max=tree[R(root)]._max;
tree[root].posl=tree[R(root)].posl;
tree[root].posr=tree[R(root)].posr;
}
}
int main()
{
int n;
while(scanf("%d",&n)!=EOF)
{
int l,r,b;
Create(0,n,1);
while(scanf("%d %d %d",&l,&r,&b))
{
if(l==-1) break;
Updata(l,r,b,1);
}
printf("%d %d\n",tree[1].posl,tree[1].posr);
}
return 0;
}
]]>
DP銆?/span>
錛戙?span style="font-family: 瀹嬩綋;">姣忎竴琛屾渶澶氬彧鍙互璧頒竴嬈℃嵎寰勶紝姣忎竴鍒椾篃鏄渶澶氬彧鍙互璧頒竴嬈℃嵎寰?/span>
錛掋?span style="font-family: 瀹嬩綋;">姣忔璧拌繃鎹峰緞鍚庣殑妯潗鏍囧拰綰靛潗鏍囬兘瑕佸ぇ浜庝箣鍓嶇殑鍧愭爣
鍙姹傚嚭浠庤搗鐐瑰埌緇堢偣鎵緇忚繃鐨勬渶澶氱殑鎹峰緞錛屽氨鑳藉緱鍒版渶灝戠殑璺▼銆傛瘡涓姝ョ殑鏈浼樿В鐢ㄤ箣鍓嶈蛋榪囩殑璺緞鎵姹傦紝婊¤凍鏃犲悗鏁堟э紝姣忎竴涓瓙鐘舵侀兘鍙互姹傚嚭鏈浼樿В錛屾弧瓚蟲渶浼樺瓙緇撴瀯錛屽彲浠ョ敤dp瑙ｅ喅銆?/span>
f[i]=max(f[j]+1,f[i]);
褰?/span>j鐐瑰潗鏍囧皬浜庣偣錛?/span>i鐐逛負鎹峰緞鏃訛紝璧板埌i鐐瑰潗鏍囨椂緇忚繃鐨勬渶澶氭嵎寰勬暟=max(璧板埌j鐐圭殑鏈澶氭嵎寰勬暟+1錛岃蛋鍒?/span>i鐐規椂鐨勬渶澶氭嵎寰勬暟)
鏈鍚庢壘鍑烘渶澶х殑f(i)灝辨槸鑳界粡榪囨渶澶氱殑鎹峰緞
娉ㄦ剰鍧愭爣鐨勮緭鍏ユ病鏈夐『搴忔э紝瑕佽繘琛屾帓鍒椼?br />
#include <iostream>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <cstdio>
using namespace std;
const int MAXN=1003;
typedef struct
{
int a,b;
}point;
point p[MAXN];
int f[1003];
bool cmp(point p1,point p2)
{
if(p1.a==p2.a) return p1.b<p2.b;
return p1.a<p2.a;
}
int main()
{
//freopen("1.in","r",stdin);
int m,n;
while(cin>>n>>m)
{
int k;
cin>>k;
for(int i=0;i<k;i++)
{
cin>>p[i].a>>p[i].b;
f[i]=1;
}
sort(p,p+k,cmp);//濡傛灉妯潗鏍囩浉絳夛紝鎸夌収綰靛潗鏍囦粠灝忓埌澶ф帓搴忥紝鍚﹀垯鎸夌収妯潗鏍囦粠灝忓埌澶ф帓搴?/span>
int v=0,flag=0;
//dp
for(int i=0;i<k;i++)
{
for(int j=0;j<=i;j++)
{
if(p[i].a>p[j].a)
{
if(p[i].b>p[j].b) f[i]=max(f[j]+1,f[i]);
}
}
}
//姹傜敤鍒版渶澶氭嵎寰勭殑鐐?/span>
int ma=*max_element(f,f+k);
cout<<(int)((m+n-2*ma)*100+ma*100*sqrt(2.0)+0.5)<<endl;
}
return 0;
}
#include <cstring>
#include <algorithm>
#include <cmath>
#include <cstdio>
using namespace std;
const int MAXN=1003;
typedef struct
{
int a,b;
}point;
point p[MAXN];
int f[1003];
bool cmp(point p1,point p2)
{
if(p1.a==p2.a) return p1.b<p2.b;
return p1.a<p2.a;
}
int main()
{
//freopen("1.in","r",stdin);
int m,n;
while(cin>>n>>m)
{
int k;
cin>>k;
for(int i=0;i<k;i++)
{
cin>>p[i].a>>p[i].b;
f[i]=1;
}
sort(p,p+k,cmp);//濡傛灉妯潗鏍囩浉絳夛紝鎸夌収綰靛潗鏍囦粠灝忓埌澶ф帓搴忥紝鍚﹀垯鎸夌収妯潗鏍囦粠灝忓埌澶ф帓搴?/span>
int v=0,flag=0;
//dp
for(int i=0;i<k;i++)
{
for(int j=0;j<=i;j++)
{
if(p[i].a>p[j].a)
{
if(p[i].b>p[j].b) f[i]=max(f[j]+1,f[i]);
}
}
}
//姹傜敤鍒版渶澶氭嵎寰勭殑鐐?/span>
int ma=*max_element(f,f+k);
cout<<(int)((m+n-2*ma)*100+ma*100*sqrt(2.0)+0.5)<<endl;
}
return 0;
}
]]>
a[i][j]=a[i-1][j]+among;榪欐牱瀛樺肩殑璇濆氨鍙互杞寲鎴愭眰 鍜屾渶澶ц繛緇瓙涓?br />
| 0.031 | 156 KB |
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
const int INF=0x7fffffff-1;
int a[103][103];
int main()
{
memset(a,0,sizeof(a));
int n,among;
while(scanf("%d",&n)!=EOF)
{
for(int i=1;i<=n;i++)
for(int j=1;j<=n;j++)
{
scanf("%d",&among);
a[i][j]=a[i-1][j]+among;
}
int ans=-INF;
for(int i=0;i<n;i++)
{
for(int j=i+1;j<=n;j++)
{
int maxnum=a[j][1]-a[i][1];
ans=max(maxnum,ans);
for(int k=2;k<=n;k++)
{
if(a[j][k]-a[i][k]+maxnum<a[j][k]-a[i][k])
{
maxnum=a[j][k]-a[i][k];
ans=max(maxnum,ans);
}
else
{
maxnum+=a[j][k]-a[i][k];
ans=max(maxnum,ans);
}
}
}
}
printf("%d\n",ans);
}
return 0;
}
]]>
榪欎釜棰樺緢涔呬互鍓嶅仛榪囷紝铏界劧AC浜嗕絾鏄敊鐨勩備箣鍓嶅仛鐨勬椂鍊欒寰楁湁涓緇勬暟鎹秴int浜嗭紙鑰佹槸RE錛夛紝鑰屼笖褰撴椂璁や負鍙湁榪欎竴緇勬暟鎹秴浜嗭紝鎵浠ュ綋鏃跺氨鎶婅繖緇勬暟鎹繘琛岀壒孌婂寲澶勭悊浜嗐傚悗鏉ュ皬鐗涙壘鍑轟簡闂鎴戞墠鎰忚瘑鍒版牴鏈病鏈夎秴鍑篿nt錛屾垜鍘繪帀鐗規畩鍖栧鐞嗗悗鎻愪氦TLE錛屼笉鏄疪E錛屾垜寮濮嬬籂緇撳綋鏃跺埌搴曟槸鎬庝箞鍋氱殑銆?br />鎴戦噸鏂版鏌ヤ簡涓閬嶄唬鐮侊紝鍙戠幇鎴戠殑鍝堝笇綆楁硶鍔犱笂閭ｇ粍鐗規畩鏁版嵁錛屾椂闂村鏉傚害O錛坣*m錛夛紝n杈懼埌100涓囷紝m杈懼埌1涓囥傝繖鏃墮棿浼や笉璧峰晩銆傚悗鏉ユ兂鎯沖搱甯岃繕鍙互浼樺寲錛屼簬鏄垜灝辨敼浜嗕竴涓嬪搱甯岀畻娉曪紝澶嶆潅搴﹂檷浣庡埌浜哋錛坣錛夛紝鏈緇堜篃欏哄埄AC銆?br />
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cstring>
const int MAX=100003;
const int MAXSUM=12500000;
int a[1003];
void g()
{
for(int i=-50;i<=50;i++)
{
a[i+50]=i*i*i;
}
}
template <class T>
class hash
{
private:
int pos;
int next[MAX];
int head[MAX];
int key[MAX];
int cnt[MAX];
public:
int count;
void search(const int x);
bool search1(const int x);
void push(const int x);
void clear();
};
template <class T>
inline bool hash<T>::search1(const int x)
{
int temp=abs(x)%MAX;
int t=head[temp];
while(t!=-1)
{
if (x==key[t])
{
cnt[t]++;
return true;
}
t=next[t];
}
return false;
}
template <class T>
inline void hash<T>::search(const int x)
{
int temp=abs(x)%MAX;
int t=head[temp];
while(t!=-1)
{
if (x==-key[t])
{
count+=cnt[t];
}
t=next[t];
}
}
template <class T>
inline void hash<T>::push(const int x)
{
if(search1(x)) return;
int temp=abs(x)%MAX;
if (head[temp]!=-1)
{
next[pos]=head[temp];
}
head[temp]=pos;
key[pos]=x;
cnt[pos]=1;
pos++;
}
template <class T>
void hash<T>::clear()
{
count=0;
pos=0;
memset(next,-1,sizeof(next));
memset(head,-1,sizeof(head));
memset(cnt,0,sizeof(cnt));
}
hash<int> h;
int main()
{
//freopen("in.txt","r",stdin);
int T;
scanf("%d",&T);
memset(a,0,sizeof(0));
g();
while(T--)
{
h.clear();
int a1,a2,a3,a4,a5;
int i,j,k;
int n;
scanf("%d%d%d%d%d",&a1,&a2,&a3,&a4,&a5);
for(i=-50;i<=50;i++)
{
for(j=-50;i!=0&&j<=50;j++)
{
if(j==0) continue;
n=a1*a[i+50]+a2*a[j+50];
h.push(n);
}
}
for(i=-50;i<=50;i++)
{
for(j=-50;i!=0&&j<=50;j++)
{
for(k=-50;j!=0&&k<=50;k++)
{
if(k==0) continue;
n=a3*a[i+50]+a4*a[j+50]+a5*a[k+50];
if(n > MAXSUM || n < -MAXSUM)
continue;
h.search(n);
}
}
}
printf("%d\n",h.count);
}
return 0;
}
]]>