鏈矙鑼跺湪2009騫?鏈堟浘緇忓湪k-i+1}, i<=k<j錛岀浜岄」闇瑕佹弧瓚沖師瀛楃涓瞇i..j]榪欎竴孌墊伆濂界敱[i..k]榪欎竴孌電殑鑻ュ共嬈″鍒跺緱鍒皚
錛堝姞涓妅-i+1鏄洜涓哄浜庝互涓嬩笁縐嶉噸鍙犲瓧絎︿覆錛屼笉鍘嬬緝姣斿帇緙╄鐭細AA鍨嬨丄AA鍨嬨丄BAB鍨嬶級
杈圭晫錛欶[i][i]=1錛?br />
闂鏄湪涓婅堪鏂圭▼鐨勭浜岄」閲屽浣曟眰鍑哄彲琛岀殑k銆傛樉鐒訛紝鍙渶瑕佸[i..j]榪欎竴孌典綔exKMP錛屾眰鍑簄x錛岀劧鍚巏鍙褰撲笖浠呭綋婊¤凍錛氾紙1錛塶x[k+1]=j-k錛涳紙2錛?k-i+1)|(j-i+1)錛?br />
涓嶈繃錛屾湰棰樺湪鍐檈xKMP鐨勮繃紼嬩腑浼氬嚭鐜板緢鍥х殑闂……鐢變簬涓嬫爣涓嶆槸浠?寮濮嬶紝鑰屾槸浠巌寮濮嬶紝鎵浠ュ緢澶氬湴鏂瑰叧浜庝笅鏍囩殑璁＄畻閮借鏀規帀錛岄潪甯鎬笉鏂逛究錛岃屼笖寰堝鏄撶柕鎺夈備笌鍏惰繖鏍鳳紝榪樹笉濡傛妸[i..j]榪欎竴孌靛鍒跺埌涓涓柊瀛楃涓查噷錛屼笅鏍囦粠0寮濮嬨傚浜庡叾瀹冪殑鏌愪簺瀛楃涓茬畻娉曞拰鏁版嵁緇撴瀯錛屾垨璁鎬篃鏄繖鏍峰洤……
浠ｇ爜錛?br />
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
#define re(i, n) for (int i=0; i<n; i++)
#define re1(i, n) for (int i=1; i<=n; i++)
#define re2(i, l, r) for (int i=l; i<r; i++)
#define re3(i, l, r) for (int i=l; i<=r; i++)
#define rre(i, n) for (int i=n-1; i>=0; i--)
#define rre1(i, n) for (int i=n; i>0; i--)
#define rre2(i, r, l) for (int i=r-1; i>=l; i--)
#define rre3(i, r, l) for (int i=r; i>=l; i--)
#define ll long long
const int MAXN = 110, INF = ~0U >> 2;
int n, F[MAXN][MAXN], nx[MAXN], res;
char ss[MAXN + 1], ss0[MAXN + 1];
void init()
{
scanf("%s", ss); n = strlen(ss);
}
int sol0(int l, int r)
{
int W = r - l + 1; re3(i, l, r) ss0[i - l] = ss[i];
nx[0] = W; nx[1] = nx[0] - 1; re(i, W) if (ss0[i] != ss0[i + 1]) {nx[1] = i; break;}
int k = 1, len, p = k + nx[k] - 1, x, y;
re2(i, 2, W) {
len = nx[i - k];
if (i + len <= p) nx[i] = len; else {
x = p + 1; y = p - i + 1; if (y < 0) {x++; y = 0;}
for (; x<=W && ss0[x]==ss0[y]; x++, y++) ;
nx[i] = y; k = i; p = i + y - 1;
}
}
int res0 = INF, tmp, V;
re2(i, 1, W) if (!(W % i) && nx[i] == W - i) {
V = F[l][l + i - 1] + 2; tmp = W / i; while (tmp) {tmp /= 10; V++;}
if (W < V) V = W;
if (V < res0) res0 = V;
}
return res0;
}
void solve()
{
re(i, n) F[i][i] = 1;
int j, tmp;
re2(x, 1, n) re(i, n-x) {
j = i + x; F[i][j] = sol0(i, j);
re2(k, i, j) {tmp = F[i][k] + F[k + 1][j]; if (tmp < F[i][j]) F[i][j] = tmp;}
}
res = F[0][n - 1];
}
void pri()
{
printf("%d\n", res);
}
int main()
{
init();
solve();
pri();
return 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
#define re(i, n) for (int i=0; i<n; i++)
#define re1(i, n) for (int i=1; i<=n; i++)
#define re2(i, l, r) for (int i=l; i<r; i++)
#define re3(i, l, r) for (int i=l; i<=r; i++)
#define rre(i, n) for (int i=n-1; i>=0; i--)
#define rre1(i, n) for (int i=n; i>0; i--)
#define rre2(i, r, l) for (int i=r-1; i>=l; i--)
#define rre3(i, r, l) for (int i=r; i>=l; i--)
#define ll long long
const int MAXN = 110, INF = ~0U >> 2;
int n, F[MAXN][MAXN], nx[MAXN], res;
char ss[MAXN + 1], ss0[MAXN + 1];
void init()
{
scanf("%s", ss); n = strlen(ss);
}
int sol0(int l, int r)
{
int W = r - l + 1; re3(i, l, r) ss0[i - l] = ss[i];
nx[0] = W; nx[1] = nx[0] - 1; re(i, W) if (ss0[i] != ss0[i + 1]) {nx[1] = i; break;}
int k = 1, len, p = k + nx[k] - 1, x, y;
re2(i, 2, W) {
len = nx[i - k];
if (i + len <= p) nx[i] = len; else {
x = p + 1; y = p - i + 1; if (y < 0) {x++; y = 0;}
for (; x<=W && ss0[x]==ss0[y]; x++, y++) ;
nx[i] = y; k = i; p = i + y - 1;
}
}
int res0 = INF, tmp, V;
re2(i, 1, W) if (!(W % i) && nx[i] == W - i) {
V = F[l][l + i - 1] + 2; tmp = W / i; while (tmp) {tmp /= 10; V++;}
if (W < V) V = W;
if (V < res0) res0 = V;
}
return res0;
}
void solve()
{
re(i, n) F[i][i] = 1;
int j, tmp;
re2(x, 1, n) re(i, n-x) {
j = i + x; F[i][j] = sol0(i, j);
re2(k, i, j) {tmp = F[i][k] + F[k + 1][j]; if (tmp < F[i][j]) F[i][j] = tmp;}
}
res = F[0][n - 1];
}
void pri()
{
printf("%d\n", res);
}
int main()
{
init();
solve();
pri();
return 0;
}
]]>
]]>
錛?錛夊畠涓瀹氭槸涓涓瀬宸︾粨鐐癸紙灝辨槸浠庢牴寰瀹冪殑璺笂涓鐩撮兘鏄部鐫宸﹂摼璧幫級錛屽洜涓烘彃鍏ョ殑鏃跺欐瘡嬈￠兘鏄彃鍏ュ埌宸﹀瓙鏍戜腑錛?br />錛?錛夊畠涓瀹氭湪鏈夊彸瀛愭爲錛屽洜涓烘彃鍏ョ殑鏃跺欐瘡嬈￠兘鏄妸鍘熸潵鐨勬煇媯靛瓙鏍戜綔涓烘柊緇撶偣鐨勫乏瀛愭爲錛?br />
婊¤凍錛?錛夛紙2錛夌殑緇撶偣鍙兘鏈夊涓紝浣嗙揣鎺ョ潃鍙互鍙戠幇錛岃繖涓?strong style="color: red">鏂滃爢涓殑姣忎釜緇撶偣濡傛灉鏈ㄦ湁宸﹀瓙緇撶偣錛岄偅涔堜篃鏈ㄦ湁鍙沖瓙緇撶偣錛堟垨鑰呰錛屾瘡涓潪鍙剁粨鐐歸兘鏈夊乏瀛愭爲錛夛紝鑰屽湪鎻掑叆涓涓粨鐐逛箣鍓嶏紝鍏舵墍鏈夌殑紲栧厛閮借浜ゆ崲浜嗗乏鍙沖瓙鏍戯紝鎵浠ワ紝鑻ユ柊緇撶偣鐨勭鍏堜腑鏈夋弧瓚籌紙1錛夛紙2錛夌殑錛屼笖鏂扮粨鐐逛笉鏄彾緇撶偣錛岄偅涔堝湪鏂扮粨鐐規彃鍏ヤ箣鍓嶏紝榪欎釜婊¤凍錛?錛夛紙2錛夌殑紲栧厛蹇呯劧鏄彧鏈夊彸瀛愭爲鑰屾湪鏈夊乏瀛愭爲鐨勶紝榪欎笌涓婇潰鐨勯偅涓ц川鐭涚浘錛屾墍浠ワ紝鍙互寰楀嚭錛?strong>鏈鍚庢彃鍏ョ殑閭ｄ釜緇撶偣涓瀹氭槸婊¤凍錛?錛夛紙2錛夌殑緇撶偣涓紝娣卞害鏈灝忕殑閭ｄ釜錛堣涓篨錛夛紝闄ら潪X鐨勫乏瀛愮粨鐐規槸鍙剁粨鐐癸紝姝ゆ椂涓轟簡婊¤凍瀛楀吀搴忔渶灝忥紝搴旇鍙朮鐨勫乏瀛愮粨鐐逛負鏈鍚庢彃鍏ョ殑銆?/span>鎵懼埌榪欎釜鏈鍚庢彃鍏ョ殑緇撶偣浠ュ悗錛屽彧闇瑕佹妸瀹冨垹鎺夛紝騫舵妸瀹冪殑鎵鏈夌鍏堜氦鎹㈠乏鍙沖瓙鏍戯紝灝辨槸鎻掑叆璇ョ粨鐐逛互鍓嶇殑鐘舵佷簡銆傝繖鏍峰彲浠ユ壘鍒板瓧鍏稿簭鏈灝忕殑鎻掑叆欏哄簭銆?br />———————————————————————————————————————————————————
浣嗘槸錛岃繖涓鐨勬剰涔夎繕涓嶆浜庢錛屽繀欏昏鎼炴竻妤氭枩鍫嗗埌搴曟槸浠涔堬紝鏈変粈涔堝簲鐢ㄥ洤……
鏂滃爢鏄彲鍚堝茍鍫嗙殑涓縐嶅疄鐜板艦寮忥紝鍏舵洿紼沖畾鐨勫疄鐜版槸宸﹀亸鏍戯紙鏂滃爢鍙兘鍋氬埌鍧囨憡logN錛岃屽乏鍋忔爲鍒欏彲浠ヤ弗鏍煎仛鍒版瘡嬈℃搷浣淥(logN)錛夈?br />鏂滃爢鏈鍏稿瀷鐨勭壒鐐癸紝涓婇潰宸茬粡璇磋繃浜嗭紝濡傛灉涓涓粨鐐規病鏈夊乏瀛愭爲錛岄偅涔堝畠涔熶竴瀹氭病鏈夊彸瀛愭爲銆傝繖鏍鳳紝澶у鏁版枩鍫嗙湅涓婂幓鏄線宸﹀炬枩鐨勶紙榪欎篃灝辨槸瀹冪殑鍚嶅瓧鐨勭敱鏉?#8230;…錛夈傚鏋滅粰姣忎釜緇撶偣鍔犱笂涓涓?span style="color: #339966">璺濈鍊糳ist[]錛屼負璇ョ粨鐐瑰埌瀹冩渶榪戠殑娌℃湁鍙沖瓙鏍戠殑瀛愮粨鐐圭殑璺濈錛屽茍涓旀弧瓚充換鎰忕粨鐐圭殑宸﹀瓙緇撶偣鐨勮窛紱誨奸兘涓嶅皬浜庡彸瀛愮粨鐐圭殑璺濈鍊?/strong>鐨勮瘽錛屽氨鎴愪簡宸﹀亸鏍戝洤……
鍙悎騫跺爢錛岄【鍚嶆濅箟錛屽畠蹇呴』婊¤凍涓や釜鎬ц川錛氾紙1錛夋槸鍫嗭紝涔熷氨鏄瘡涓粨鐐圭殑鍏抽敭瀛楅兘涓嶅ぇ浜庯紙灝忛《鍫嗭級/涓嶅皬浜庯紙澶ч《鍫嗭級鍏朵袱涓瓙緇撶偣鐨勫叧閿瓧錛涳紙2錛夊畠蹇呴』鍦∣(logN)鏃墮棿鍐呭畬鎴愬悎騫舵搷浣滐紝鍗沖皢涓や釜鍫嗗悎騫朵負涓涓紝涓斿悎騫舵垚鐨勫爢浠嶆弧瓚沖師鏉ョ殑鎬ц川銆?br />鏂滃爢鐨勫悎騫舵搷浣滄湁鐐瑰儚鏌愪簺鍑芥暟寮忔暟鎹粨鏋勶紝浣嗗畠騫朵笉浼氬姩鐢ㄩ澶栫殑絀洪棿銆傝鍚堝茍鎿嶄綔浣跨敤閫掑綊瀹炵幇錛岃涓や釜鏂滃爢錛堝皬欏跺爢錛夌殑鏍圭粨鐐逛負A銆丅錛岃嫢A鍜孊涓殑鏌愪竴涓負絀猴紝鍒欒繑鍥炲彟涓涓紱鑻鍜孊鍧囬潪絀猴紝鍒欏厛灝嗗畠浠腑鍏抽敭瀛楀皬鐨勯偅涓殑鍙沖瓙鏍戜笌鍏抽敭瀛楀ぇ鐨勯偅涓殑鏁存５鏍戝悎騫訛紝浣滀負鍏抽敭瀛楀皬鐨勯偅涓殑鏂扮殑鍙沖瓙鏍戯紝鐒跺悗錛屽鏋滄槸宸﹀亸鏍戠殑璇濊鏇存柊dist錛岃嫢dist涓嶆弧瓚?#8220;宸︿笉灝忎簬鍙?#8221;錛岃繕瑕佷氦鎹㈠乏鍙沖瓙鏍戙?br />
鏂滃爢鍙互鏀寔鐨勬搷浣滄湁錛堟寚鑳藉湪O(logN)鏃墮棿鍐呭畬鎴愮殑鎿嶄綔錛夛細
錛?錛夋彃鍏ョ粨鐐癸細錛堢敤鍚堝茍瀹炵幇錛夛紱
錛?錛夊垹闄や換鎰忕粨鐐癸細錛堝皢寰呭垹闄ょ粨鐐圭殑涓ゆ５瀛愭爲鍚堝茍錛屽彇浠ｅ師鏉ョ殑浣嶇疆錛岃嫢鏄乏鍋忔爲鐨勮瘽榪樿寰涓婃洿鏂癲ist鐩村埌dist涓嶅彉涓烘錛屾煇璁烘枃閲屾湁璇佹槑錛屾瘡嬈″垹闄ゆ洿鏂癲ist嬈℃暟涓嶄細瓚呰繃2logN錛夛紱
錛?錛夊悎騫朵袱涓枩鍫嗭紱
錛?錛夋壘鏈灝?澶у鹼紱
錛?錛夋眰浠ユ煇涓粨鐐逛負鏍圭殑瀛愭爲澶у皬錛堢淮鎶z鍗沖彲錛夛紱
鏂滃爢涓嶈兘鏀寔鐨勬搷浣滄湁錛堟寚涓嶈兘鍦∣(logN)鏃墮棿鍐呭畬鎴愮殑鎿嶄綔錛夛細
錛?錛夋煡鎵句換鎰忕粨鐐廣傚洜姝わ紝鑻ヨ鍒犻櫎鏌愪釜鎸囧畾緇撶偣錛屽垯蹇呴』鍏堢敤涓嬫爣絳夌儲寮曞埌瀹冿紱
錛?錛夋壘絎琄灝忥紙濡傛灉榪欎釜閮借兘瀹炵幇鐨勮瘽錛屾枩鍫嗗氨鍙互鏇夸唬騫寵 鏍戜簡鍥?#8230;…榪樻槸鍙悎騫跺鉤琛℃爲……錛夛紱
錛?錛夋壘鏌愪釜緇撶偣鎵鍦ㄦ爲鐨勬牴緇撶偣錛堜絾鏄厤鍚堝茍鏌ラ泦+绱㈠紩鍙互瀹炵幇錛岃瑙丠DU1512錛夛紱
鑷充簬緙栫▼澶嶆潅搴︽柟闈?#8230;…闈炲父闈炲父濂藉啓錛佸熀鏈笂涓涓悎騫舵搷浣滃氨澶熶簡錛?lt;10琛岋紙鏂滃爢鐨勫ソ鍐欑▼搴︿粎嬈′簬騫舵煡闆嗗拰鏅氬爢錛夛紱
鍐欑殑涔嬪悗鏈変笁涓富瑕佺殑鏄撶柕鐐癸細
錛?錛夊悎騫剁殑鏃跺欏埆蹇樹簡鏇存柊涓浜涗笢涓滐紝灝ゅ叾鍒繕浜嗚繑鍥炴牴緇撶偣錛?br />錛?錛夛紙鏋佹槗鐤電殑錛侊紒錛夊鏋滆鍒犻櫎鏌愪釜緇撶偣錛屽繀欏繪妸瀹冪殑鎵鏈変俊鎭仮澶嶅埌瀛ょ珛緇撶偣鐨勭姸鎬侊紝鍗蟲柇寮涓庡師鏍戠殑涓鍒囪仈緋伙紙pr銆丩銆丷鍏ㄩ儴緗?錛夛紝dist錛堝鏋滄槸宸﹀亸鏍戯級緗?銆乻z緗?錛涳紙3錛変笅鏍囦粠1寮濮嬶紝0鍙風粨鐐逛綔鐗規畩鐢ㄩ旓紙dist鍊間負-1錛宻z鍊間負0錛夛紝濡傛灉鏌愪釜緇撶偣鐨刾r銆丩銆丷涓嶅瓨鍦ㄥ垯涓?錛?br />
渚嬮錛堢敱浜庢兂紼沖畾錛屾湰娌欒尪鍏ㄩ兘鏄敤宸﹀亸鏍戝啓鐨勫洤錛夛細
銆?銆?a title="HDU1512" >HDU1512
鍩烘湰鎿嶄綔棰橈紝閰嶅悎騫舵煡闆?绱㈠紩鎵炬牴鍗沖彲錛?
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
#define re(i, n) for (int i=0; i<n; i++)
#define re1(i, n) for (int i=1; i<=n; i++)
#define re2(i, l, r) for (int i=l; i<r; i++)
#define re3(i, l, r) for (int i=l; i<=r; i++)
#define rre(i, n) for (int i=n-1; i>=0; i--)
#define rre1(i, n) for (int i=n; i>0; i--)
#define rre2(i, r, l) for (int i=r-1; i>=l; i--)
#define rre3(i, r, l) for (int i=r; i>=l; i--)
#define ll long long
const int MAXN = 100010, INF = ~0U >> 2;
int n, u[MAXN], rt[MAXN], V[MAXN], dist[MAXN], pr[MAXN], L[MAXN], R[MAXN], res;
int UFS_find(int x)
{
int tmp = x, r = x; while (u[r] >= 0) r = u[r]; while (x != r) {tmp = u[x]; u[x] = r; x = tmp;} return r;
}
void UFS_union(int s1, int s2, int rt0)
{
if (u[s1] >= u[s2]) {u[s1] = s2; u[s2]--; rt[s2] = rt0;} else {u[s2] = s1; u[s1]--; rt[s1] = rt0;}
}
int heap_union(int s1, int s2)
{
if (!s1) return s2; else if (!s2) return s1; else if (V[s1] >= V[s2]) {
int z = heap_union(R[s1], s2);
R[s1] = z; pr[z] = s1; if (dist[L[s1]] < dist[z]) {int tmp = L[s1]; L[s1] = R[s1]; R[s1] = tmp;}
dist[s1] = dist[R[s1]] + 1; return s1;
} else {
int z = heap_union(s1, R[s2]);
R[s2] = z; pr[z] = s2; if (dist[L[s2]] < dist[z]) {int tmp = L[s2]; L[s2] = R[s2]; R[s2] = tmp;}
dist[s2] = dist[R[s2]] + 1; return s2;
}
}
void prepare()
{
dist[0] = -1; re1(i, n) {u[i] = -1; rt[i] = i; dist[i] = pr[i] = L[i] = R[i] = 0;}
}
void solve(int x, int y)
{
int s1 = UFS_find(x), s2 = UFS_find(y); if (s1 == s2) {res = -1; return;}
int rt1 = rt[s1], rt2 = rt[s2];
int z1 = heap_union(L[rt1], R[rt1]); L[rt1] = R[rt1] = pr[z1] = 0;
V[rt1] /= 2; z1 = heap_union(rt1, z1); pr[z1] = 0;
int z2 = heap_union(L[rt2], R[rt2]); L[rt2] = R[rt2] = pr[z2] = 0;
V[rt2] /= 2; z2 = heap_union(rt2, z2); pr[z2] = 0;
int z = heap_union(z1, z2); pr[z] = 0;
UFS_union(s1, s2, z);
res = V[z];
}
int main()
{
int m, x0, y0;
while (scanf("%d", &n) != EOF) {
re1(i, n) scanf("%d", &V[i]); prepare();
scanf("%d", &m);
re(i, m) {
scanf("%d%d", &x0, &y0);
solve(x0, y0);
printf("%d\n", res);
}
}
return 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
#define re(i, n) for (int i=0; i<n; i++)
#define re1(i, n) for (int i=1; i<=n; i++)
#define re2(i, l, r) for (int i=l; i<r; i++)
#define re3(i, l, r) for (int i=l; i<=r; i++)
#define rre(i, n) for (int i=n-1; i>=0; i--)
#define rre1(i, n) for (int i=n; i>0; i--)
#define rre2(i, r, l) for (int i=r-1; i>=l; i--)
#define rre3(i, r, l) for (int i=r; i>=l; i--)
#define ll long long
const int MAXN = 100010, INF = ~0U >> 2;
int n, u[MAXN], rt[MAXN], V[MAXN], dist[MAXN], pr[MAXN], L[MAXN], R[MAXN], res;
int UFS_find(int x)
{
int tmp = x, r = x; while (u[r] >= 0) r = u[r]; while (x != r) {tmp = u[x]; u[x] = r; x = tmp;} return r;
}
void UFS_union(int s1, int s2, int rt0)
{
if (u[s1] >= u[s2]) {u[s1] = s2; u[s2]--; rt[s2] = rt0;} else {u[s2] = s1; u[s1]--; rt[s1] = rt0;}
}
int heap_union(int s1, int s2)
{
if (!s1) return s2; else if (!s2) return s1; else if (V[s1] >= V[s2]) {
int z = heap_union(R[s1], s2);
R[s1] = z; pr[z] = s1; if (dist[L[s1]] < dist[z]) {int tmp = L[s1]; L[s1] = R[s1]; R[s1] = tmp;}
dist[s1] = dist[R[s1]] + 1; return s1;
} else {
int z = heap_union(s1, R[s2]);
R[s2] = z; pr[z] = s2; if (dist[L[s2]] < dist[z]) {int tmp = L[s2]; L[s2] = R[s2]; R[s2] = tmp;}
dist[s2] = dist[R[s2]] + 1; return s2;
}
}
void prepare()
{
dist[0] = -1; re1(i, n) {u[i] = -1; rt[i] = i; dist[i] = pr[i] = L[i] = R[i] = 0;}
}
void solve(int x, int y)
{
int s1 = UFS_find(x), s2 = UFS_find(y); if (s1 == s2) {res = -1; return;}
int rt1 = rt[s1], rt2 = rt[s2];
int z1 = heap_union(L[rt1], R[rt1]); L[rt1] = R[rt1] = pr[z1] = 0;
V[rt1] /= 2; z1 = heap_union(rt1, z1); pr[z1] = 0;
int z2 = heap_union(L[rt2], R[rt2]); L[rt2] = R[rt2] = pr[z2] = 0;
V[rt2] /= 2; z2 = heap_union(rt2, z2); pr[z2] = 0;
int z = heap_union(z1, z2); pr[z] = 0;
UFS_union(s1, s2, z);
res = V[z];
}
int main()
{
int m, x0, y0;
while (scanf("%d", &n) != EOF) {
re1(i, n) scanf("%d", &V[i]); prepare();
scanf("%d", &m);
re(i, m) {
scanf("%d%d", &x0, &y0);
solve(x0, y0);
printf("%d\n", res);
}
}
return 0;
}
銆?銆?a title="HDU3031" >HDU3031
緇煎悎鎿嶄綔棰橈紝闇瑕乻z錛屽悓鏃朵篃鍙互鑰冨療鏁版嵁緇撴瀯鐨勭患鍚堝簲鐢ㄨ兘鍔涖?
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
using namespace std;
#define re(i, n) for (int i=0; i<n; i++)
#define re1(i, n) for (int i=1; i<=n; i++)
#define re2(i, l, r) for (int i=l; i<r; i++)
#define re3(i, l, r) for (int i=l; i<=r; i++)
#define rre(i, n) for (int i=n-1; i>=0; i--)
#define rre1(i, n) for (int i=n; i>0; i--)
#define rre2(i, r, l) for (int i=r-1; i>=l; i--)
#define rre3(i, r, l) for (int i=r; i>=l; i--)
#define ll long long
const int MAXN = 1000010, MAXM = 101, MAXLEN_M = 10010, INF = ~0U >> 2;
int n, m, len[MAXM], V0[MAXM][MAXLEN_M], root[2];
int V[MAXN], dist[MAXN], pr[MAXN], L[MAXN], R[MAXN], sz[MAXN];
bool FS;
void upd(int x)
{
sz[x] = sz[L[x]] + sz[R[x]] + 1;
}
int heap_union(int s1, int s2)
{
if (!s1) return s2; else if (!s2) return s1; else if (V[s1] >= V[s2]) {
int s0 = heap_union(R[s1], s2);
pr[s0] = s1; R[s1] = s0; if (dist[L[s1]] < dist[s0]) {int tmp = L[s1]; L[s1] = R[s1]; R[s1] = tmp;} dist[s1] = dist[R[s1]] + 1; upd(s1);
return s1;
} else {
int s0 = heap_union(s1, R[s2]);
pr[s0] = s2; R[s2] = s0; if (dist[L[s2]] < dist[s0]) {int tmp = L[s2]; L[s2] = R[s2]; R[s2] = tmp;} dist[s2] = dist[R[s2]] + 1; upd(s2);
return s2;
}
}
void opr_T(int x)
{
sort(V0[x], V0[x] + len[x]); int root0 = n + 1;
rre(i, len[x]) {
n++; if (i == len[x] - 1) pr[n] = 0; else pr[n] = n - 1; if (i) L[n] = n + 1; else L[n] = 0; R[n] = dist[n] = 0; V[n] = V0[x][i]; sz[n] = i + 1;
}
root[FS] = heap_union(root[FS], root0);
}
void opr_A(int x)
{
V[root[FS]] += x;
}
void opr_E(int x)
{
int root0 = root[FS], z0; pr[z0 = heap_union(L[root0], R[root0])] = 0; L[root0] = R[root0] = dist[root0] = 0; sz[root0] = 1; V[root0] = x;
root[FS] = heap_union(z0, root0);
}
void opr_L()
{
int root0 = root[FS], z0; pr[z0 = heap_union(L[root0], R[root0])] = 0; L[root0] = R[root0] = dist[root0] = 0; sz[root0] = 1;
}
void opr_C()
{
int root0 = root[0], root1 = root[1];
if (V[root0] > V[root1]) {
root[0] = heap_union(root0, root1); root[1] = 0;
} else if (V[root0] < V[root1]) {
root[1] = heap_union(root0, root1); root[0] = 0;
}
}
int main()
{
int tests, sc0 = 0, sc1 = 0, P, tmp; char ssss[10];
scanf("%d", &tests);
re(testno, tests) {
scanf("%d%d", &P, &m);
re(i, m) scanf("%d", &len[i]);
re(i, m) re(j, len[i]) scanf("%d", &V0[i][j]); n = root[0] = root[1] = 0; dist[0] = -1; sz[0] = 0; FS = 0;
re(i, P) {
scanf("%s", ssss);
if (ssss[0] == 'T') {scanf("%d", &tmp); opr_T(--tmp);}
else if (ssss[0] == 'A') {scanf("%d", &tmp); opr_A(tmp);}
else if (ssss[0] == 'E') {scanf("%d", &tmp); opr_E(tmp);}
else if (ssss[0] == 'L') opr_L(); else opr_C();
FS = !FS;
}
printf("%d:%d\n", sz[root[0]], sz[root[1]]);
if (sz[root[0]] >= sz[root[1]]) sc0++; else sc1++;
}
if (sc0 > sc1) puts("Hahaha
I win!!"); else puts("I will be back!!");
return 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
using namespace std;
#define re(i, n) for (int i=0; i<n; i++)
#define re1(i, n) for (int i=1; i<=n; i++)
#define re2(i, l, r) for (int i=l; i<r; i++)
#define re3(i, l, r) for (int i=l; i<=r; i++)
#define rre(i, n) for (int i=n-1; i>=0; i--)
#define rre1(i, n) for (int i=n; i>0; i--)
#define rre2(i, r, l) for (int i=r-1; i>=l; i--)
#define rre3(i, r, l) for (int i=r; i>=l; i--)
#define ll long long
const int MAXN = 1000010, MAXM = 101, MAXLEN_M = 10010, INF = ~0U >> 2;
int n, m, len[MAXM], V0[MAXM][MAXLEN_M], root[2];
int V[MAXN], dist[MAXN], pr[MAXN], L[MAXN], R[MAXN], sz[MAXN];
bool FS;
void upd(int x)
{
sz[x] = sz[L[x]] + sz[R[x]] + 1;
}
int heap_union(int s1, int s2)
{
if (!s1) return s2; else if (!s2) return s1; else if (V[s1] >= V[s2]) {
int s0 = heap_union(R[s1], s2);
pr[s0] = s1; R[s1] = s0; if (dist[L[s1]] < dist[s0]) {int tmp = L[s1]; L[s1] = R[s1]; R[s1] = tmp;} dist[s1] = dist[R[s1]] + 1; upd(s1);
return s1;
} else {
int s0 = heap_union(s1, R[s2]);
pr[s0] = s2; R[s2] = s0; if (dist[L[s2]] < dist[s0]) {int tmp = L[s2]; L[s2] = R[s2]; R[s2] = tmp;} dist[s2] = dist[R[s2]] + 1; upd(s2);
return s2;
}
}
void opr_T(int x)
{
sort(V0[x], V0[x] + len[x]); int root0 = n + 1;
rre(i, len[x]) {
n++; if (i == len[x] - 1) pr[n] = 0; else pr[n] = n - 1; if (i) L[n] = n + 1; else L[n] = 0; R[n] = dist[n] = 0; V[n] = V0[x][i]; sz[n] = i + 1;
}
root[FS] = heap_union(root[FS], root0);
}
void opr_A(int x)
{
V[root[FS]] += x;
}
void opr_E(int x)
{
int root0 = root[FS], z0; pr[z0 = heap_union(L[root0], R[root0])] = 0; L[root0] = R[root0] = dist[root0] = 0; sz[root0] = 1; V[root0] = x;
root[FS] = heap_union(z0, root0);
}
void opr_L()
{
int root0 = root[FS], z0; pr[z0 = heap_union(L[root0], R[root0])] = 0; L[root0] = R[root0] = dist[root0] = 0; sz[root0] = 1;
}
void opr_C()
{
int root0 = root[0], root1 = root[1];
if (V[root0] > V[root1]) {
root[0] = heap_union(root0, root1); root[1] = 0;
} else if (V[root0] < V[root1]) {
root[1] = heap_union(root0, root1); root[0] = 0;
}
}
int main()
{
int tests, sc0 = 0, sc1 = 0, P, tmp; char ssss[10];
scanf("%d", &tests);
re(testno, tests) {
scanf("%d%d", &P, &m);
re(i, m) scanf("%d", &len[i]);
re(i, m) re(j, len[i]) scanf("%d", &V0[i][j]); n = root[0] = root[1] = 0; dist[0] = -1; sz[0] = 0; FS = 0;
re(i, P) {
scanf("%s", ssss);
if (ssss[0] == 'T') {scanf("%d", &tmp); opr_T(--tmp);}
else if (ssss[0] == 'A') {scanf("%d", &tmp); opr_A(tmp);}
else if (ssss[0] == 'E') {scanf("%d", &tmp); opr_E(tmp);}
else if (ssss[0] == 'L') opr_L(); else opr_C();
FS = !FS;
}
printf("%d:%d\n", sz[root[0]], sz[root[1]]);
if (sz[root[0]] >= sz[root[1]]) sc0++; else sc1++;
}
if (sc0 > sc1) puts("Hahaha
I win!!"); else puts("I will be back!!");return 0;
}
]]>
]]>
姹傚浘鐨剆-t絎琄鐭畝鍗曡礬闂錛岃嫢鏈夐暱搴︾浉鍚岀殑錛屽瓧鍏稿簭灝忕殑浼樺厛銆?br />
棣栧厛錛岀敱浜庢槸綆鍗曡礬錛屾墍浠?a title="A*" href="http://www.shnenglu.com/MatoNo1/archive/2011/05/01/145456.html">A*鏄笉鑳藉仛鐨勶紝鍥犱負鏈夊彲鑳芥湁涓ゆ潯s-i錛坕涓烘煇涓腑闂寸偣錛夎礬P1鍜孭2錛孭1姣擯2鐭紝浣嗙敱浜嶱1鍒拌揪鐨勯《鐐逛笌P2涓嶅悓錛屽鑷存渶緇堟部P1鍒拌揪t鐨勮礬寰勯暱搴﹂暱浜庢部P2鍒拌揪t鐨勶紙鐢氳嚦鏈夊彲鑳芥部P1鏍規湰鍒頒笉浜唗錛夈傜劧鍚庯紝濡傛灉鐩存帴鐢―FS錛岀敱浜庤姹傜殑鏄K浼樿В錛岃屼笉鏄渶浼樿В錛屾墍浠ヤ笉鑳戒嬌鐢ㄦ渶浼樻у壀鏋濓紙鍖呮嫭鍒嗘敮闄愮晫錛夛紝鍥犳涓撻棬涓烘渶浼樻у壀鏋濇湇鍔＄殑“鏀瑰彉鎼滅儲欏哄簭”鎶宸т篃涓嶈兘浣跨敤浜嗭紝鍥犳錛岃兘澶熶嬌鐢ㄧ殑鍙湁鍙鎬у壀鏋濓紝鑰屾湰棰樼殑鏁版嵁鑼冨洿浣垮緱榪欑綆楁硶蹇呯劧TLE銆?br />
姝ｈВ鏄竴縐嶇敱榪唬鍔犳繁鎬濇兂鎵╁睍寰楀埌鐨?#8220;榪唬鍙樹紭”DFS銆傝緗竴涓礬寰勯暱搴︿笂闄怹錛屾悳绱鍒皌鐨勬墍鏈夌畝鍗曡礬錛屽湪鎼滅儲榪囩▼涓紝閬囧埌闀垮害澶т簬Z鐨勮礬寰勫氨鍋滄錛堝壀鏋濓級錛岀劧鍚庯紝鑻ュ緱鍒拌礬寰勪笉瓚矺鏉★紝鍒欏鍔燴鐨勫鹼紝閲嶆柊寮濮嬫悳绱紝鐩村埌寰楀埌鐨勮礬寰勬繪暟澶т簬絳変簬K鏉′負姝€傝繖閲屽彲浠ヨ繘琛屽惎鍙戝紡鐨勪紭鍖栵紝璁緂[i]涓虹偣i鍒皌鐨勬渶鐭礬闀垮害錛屽垯鎼滅儲榪囩▼涓紝鍋囪鐩墠鎼滃埌鐐筰錛屽垯錛堢洰鍓嶈礬寰勯暱搴?g[i]錛夋槸瀵規暣鏉¤礬寰勬渶鐭暱搴︾殑涔愯浼拌錛屽鏋滆繖涓艱秴榪囦簡Z錛屽氨鍙互鍓灊錛屼絾鍦ㄥ壀鏋濅箣鍓嶈璁頒笅榪欎釜瓚呰繃浜哯鐨勫惎鍙戝鹼紝鍙栧叾涓渶灝忕殑浣滀負涓嬩竴嬈¤凱浠ｇ殑Z鍊箋傞偅涔堝浜庡瓧鍏稿簭鑲夸箞鍔烇紵鍙互鍦ㄦ悳绱㈣繃紼嬩腑錛屽己鍒跺厛鎼滅紪鍙峰皬鐨勭粨鐐癸紝榪欐牱寰楀埌鐨剆-t璺緞蹇呯劧鏄瓧鍏稿簭閫掑鐨勩傚彟澶栧彧瑕佹眰鍑虹K鏉¤礬寰勶紝鎼滅儲灝卞彲浠ョ粓姝紝鍥犱負瀹規槗璇佹槑錛岄鐩姹傜殑絎琄鐭殑璺緞涓瀹氬凡緇忔眰鍑烘潵浜嗭紙鍙笉榪囦笉涓瀹氭槸鏈鍚庝竴鏉¤屽凡錛夛紝鎵懼埌鍗沖彲銆傛澶栵紝鍦ㄦ悳绱㈣繃紼嬩腑涓嶈蹇樹簡鍙鎬у壀鏋濓紝灝辨槸濡傛灉娌跨洰鍓嶆悳鍒扮殑璺緞宸茬粡鍒頒笉浜唗浜嗭紝鍓灊銆?br />
“榪唬鍙樹紭”DFS錛屽氨鏄緗竴涓В鐨勮瘎浠峰肩殑涓婇檺錛堟渶灝忓鹼級鎴栦笅闄愶紙鏈澶у鹼級錛屽湪鎼滅儲榪囩▼涓紝濡傛灉瀹為檯璇勪環鍊鹼紙鎴栬呭惎鍙戝鹼紝濡傛灉鍙互鍔犲惎鍙戝紡浼樺寲鐨勮瘽錛夎秺榪囪繖涓檺鍒訛紝鍒欏壀鏋濄傚湪涓嬈℃悳绱㈠悗錛屽鏋滄病鏈夊緱鍒扮鍚堣姹傜殑瑙ｏ紝灝卞皢璇ラ檺鍒跺?span style="color: red">璁句負鏈鎼滅儲榪囩▼涓秺鐣?#8220;瓚?#8221;寰楁渶榪戠殑閭ｄ釜鍊?/strong>錛岄噸鏂板紑濮嬫悳绱紝鐩村埌鎵懼埌鎵闇瑕佺殑瑙ｆ垨鑰?span style="color: red">鍙戠幇鏃犺В錛堝鏋滀竴嬈℃悳绱腑娌℃湁鍙戠敓瓚婄晫錛屽嵈浠嶇劧娌℃湁鎵懼埌瑙ｏ級涓烘銆傚叾搴旂敤涓昏浣撶幇鍦ㄤ袱涓柟闈細錛?錛夋悳绱㈡爲榪囨繁鐢氳嚦鏃犻檺娣憋紝浣嗘墍闇姹傜殑閭ｄ釜瑙ｅ嵈涓嶆繁鐨勬儏鍐碉紱錛?錛夋眰絎琄浼樿В鐨勬儏鍐點?br />
浠ｇ爜錛?
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
using namespace std;
#define re(i, n) for (int i=0; i<n; i++)
#define re1(i, n) for (int i=1; i<=n; i++)
#define re2(i, l, r) for (int i=l; i<r; i++)
#define re3(i, l, r) for (int i=l; i<=r; i++)
#define rre(i, n) for (int i=n-1; i>=0; i--)
#define rre1(i, n) for (int i=n; i>0; i--)
#define rre2(i, r, l) for (int i=r-1; i>=l; i--)
#define rre3(i, r, l) for (int i=r; i>=l; i--)
const int MAXN = 51, MAXK = 201, MAXM = 3000, INF = ~0U >> 2;
struct edge {
int a, b, w, pre, next;
} E[MAXM + MAXN], E0[MAXM + MAXN];
struct edge0 {
int a, b, w;
bool operator< (edge0 e0) const {return b < e0.b;}
} _E[MAXM];
int n, m, s, t, K, dist[MAXN], Q[MAXN + 1];
int Z, Z0, vst0[MAXN], _FL, len0, X00[MAXN], No, len[MAXK], X0[MAXK][MAXN], sum0[MAXK], reslen, res[MAXN];
bool vst[MAXN], res_ex = 0;
void init_d()
{
re(i, n) E[i].pre = E[i].next = E0[i].pre = E0[i].next = i; m = n;
}
void add_edge(int a, int b, int w)
{
E[m].a = a; E[m].b = b; E[m].w = w; E[m].pre = E[a].pre; E[m].next = a; E[a].pre = m; E[E[m].pre].next = m;
E0[m].a = b; E0[m].b = a; E0[m].w = w; E0[m].pre = E0[b].pre; E0[m].next = b; E0[b].pre = m; E0[E0[m].pre].next = m++;
}
void init()
{
int m0; scanf("%d%d%d%d%d", &n, &m0, &K, &s, &t); init_d(); s--; t--;
re(i, m0) {scanf("%d%d%d", &_E[i].a, &_E[i].b, &_E[i].w); _E[i].a--; _E[i].b--;}
sort(_E, _E + m0);
re(i, m0) add_edge(_E[i].a, _E[i].b, _E[i].w);
}
void prepare()
{
re(i, n) {vst[i] = 0; dist[i] = INF;} vst[t] = 1; dist[t] = 0; Q[0] = t;
int x, y, d0, d1;
for (int front=0, rear=0; !(!front && rear==n || front==rear+1); front==n ? front=0 : front++) {
x = Q[front]; d0 = dist[x];
for (int p=E0[x].next; p != x; p=E0[p].next) {
y = E0[p].b; d1 = d0 + E0[p].w;
if (d1 < dist[y]) {
dist[y] = d1;
if (!vst[y]) {vst[y] = 1; Q[rear==n ? rear=0 : ++rear] = y;}
}
}
vst[x] = 0;
}
}
void dfs(int x, int sum)
{
if (x == t) {
if (sum <= Z) {sum0[No] = sum; len[No] = len0; re(i, len0) X0[No][i] = X00[i]; No++; if (No == K) res_ex = 1;}
else if (sum < Z0) Z0 = sum;
return;
} else {
int h0 = sum + dist[x];
if (h0 > Z) {if (h0 < Z0) Z0 = h0; return;}
vst0[x] = ++_FL; Q[0] = x; int _x, _y;
for (int front=0, rear=0; front<=rear; front++) {
_x = Q[front];
for (int p=E[_x].next; p != _x; p=E[p].next) {
_y = E[p].b;
if (!vst[_y] && vst0[_y] != _FL) {vst0[_y] = _FL; Q[++rear] = _y;}
}
}
if (vst0[t] != _FL) return;
for (int p=E[x].next; p != x; p=E[p].next) {
_y = E[p].b;
if (!vst[_y]) {vst[_y] = 1; X00[len0++] = _y; dfs(_y, sum + E[p].w); if (res_ex) return; else {len0--; vst[_y] = 0;}}
}
}
}
void solve()
{
Z = dist[s]; int No0 = 0; _FL = 0;
while (1) {
Z0 = INF; No = 0; re(i, n) {vst[i] = 0; vst0[i] = 0;}
vst[s] = 1; len0 = 1; X00[0] = s; dfs(s, 0);
if (res_ex) {
No0 = K - No0;
re(i, K) if (sum0[i] == Z) {No0--; if (!No0) {reslen = len[i]; re(j, len[i]) res[j] = X0[i][j];}}
break;
} else if (Z0 == INF) break; else {No0 = No; Z = Z0;}
}
}
void pri()
{
if (res_ex) {
printf("%d", res[0] + 1);
re2(i, 1, reslen) printf("-%d", res[i] + 1);
puts("");
} else puts("No");
}
int main()
{
init();
prepare();
solve();
pri();
return 0;
}
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <algorithm>
using namespace std;
#define re(i, n) for (int i=0; i<n; i++)
#define re1(i, n) for (int i=1; i<=n; i++)
#define re2(i, l, r) for (int i=l; i<r; i++)
#define re3(i, l, r) for (int i=l; i<=r; i++)
#define rre(i, n) for (int i=n-1; i>=0; i--)
#define rre1(i, n) for (int i=n; i>0; i--)
#define rre2(i, r, l) for (int i=r-1; i>=l; i--)
#define rre3(i, r, l) for (int i=r; i>=l; i--)
const int MAXN = 51, MAXK = 201, MAXM = 3000, INF = ~0U >> 2;
struct edge {
int a, b, w, pre, next;
} E[MAXM + MAXN], E0[MAXM + MAXN];
struct edge0 {
int a, b, w;
bool operator< (edge0 e0) const {return b < e0.b;}
} _E[MAXM];
int n, m, s, t, K, dist[MAXN], Q[MAXN + 1];
int Z, Z0, vst0[MAXN], _FL, len0, X00[MAXN], No, len[MAXK], X0[MAXK][MAXN], sum0[MAXK], reslen, res[MAXN];
bool vst[MAXN], res_ex = 0;
void init_d()
{
re(i, n) E[i].pre = E[i].next = E0[i].pre = E0[i].next = i; m = n;
}
void add_edge(int a, int b, int w)
{
E[m].a = a; E[m].b = b; E[m].w = w; E[m].pre = E[a].pre; E[m].next = a; E[a].pre = m; E[E[m].pre].next = m;
E0[m].a = b; E0[m].b = a; E0[m].w = w; E0[m].pre = E0[b].pre; E0[m].next = b; E0[b].pre = m; E0[E0[m].pre].next = m++;
}
void init()
{
int m0; scanf("%d%d%d%d%d", &n, &m0, &K, &s, &t); init_d(); s--; t--;
re(i, m0) {scanf("%d%d%d", &_E[i].a, &_E[i].b, &_E[i].w); _E[i].a--; _E[i].b--;}
sort(_E, _E + m0);
re(i, m0) add_edge(_E[i].a, _E[i].b, _E[i].w);
}
void prepare()
{
re(i, n) {vst[i] = 0; dist[i] = INF;} vst[t] = 1; dist[t] = 0; Q[0] = t;
int x, y, d0, d1;
for (int front=0, rear=0; !(!front && rear==n || front==rear+1); front==n ? front=0 : front++) {
x = Q[front]; d0 = dist[x];
for (int p=E0[x].next; p != x; p=E0[p].next) {
y = E0[p].b; d1 = d0 + E0[p].w;
if (d1 < dist[y]) {
dist[y] = d1;
if (!vst[y]) {vst[y] = 1; Q[rear==n ? rear=0 : ++rear] = y;}
}
}
vst[x] = 0;
}
}
void dfs(int x, int sum)
{
if (x == t) {
if (sum <= Z) {sum0[No] = sum; len[No] = len0; re(i, len0) X0[No][i] = X00[i]; No++; if (No == K) res_ex = 1;}
else if (sum < Z0) Z0 = sum;
return;
} else {
int h0 = sum + dist[x];
if (h0 > Z) {if (h0 < Z0) Z0 = h0; return;}
vst0[x] = ++_FL; Q[0] = x; int _x, _y;
for (int front=0, rear=0; front<=rear; front++) {
_x = Q[front];
for (int p=E[_x].next; p != _x; p=E[p].next) {
_y = E[p].b;
if (!vst[_y] && vst0[_y] != _FL) {vst0[_y] = _FL; Q[++rear] = _y;}
}
}
if (vst0[t] != _FL) return;
for (int p=E[x].next; p != x; p=E[p].next) {
_y = E[p].b;
if (!vst[_y]) {vst[_y] = 1; X00[len0++] = _y; dfs(_y, sum + E[p].w); if (res_ex) return; else {len0--; vst[_y] = 0;}}
}
}
}
void solve()
{
Z = dist[s]; int No0 = 0; _FL = 0;
while (1) {
Z0 = INF; No = 0; re(i, n) {vst[i] = 0; vst0[i] = 0;}
vst[s] = 1; len0 = 1; X00[0] = s; dfs(s, 0);
if (res_ex) {
No0 = K - No0;
re(i, K) if (sum0[i] == Z) {No0--; if (!No0) {reslen = len[i]; re(j, len[i]) res[j] = X0[i][j];}}
break;
} else if (Z0 == INF) break; else {No0 = No; Z = Z0;}
}
}
void pri()
{
if (res_ex) {
printf("%d", res[0] + 1);
re2(i, 1, reslen) printf("-%d", res[i] + 1);
puts("");
} else puts("No");
}
int main()
{
init();
prepare();
solve();
pri();
return 0;
}
]]>