model

   1 /**************************************************
   2 
   3             模版：01背包
   4             题目：HDU2602 Bone Collector
   5 
   6 **************************************************/
   7 
   8 #include<iostream>
   9 #include<cstring>
  10 #include<cstdio>
  11 using namespace std;
  12 const int maxn=1000+10;
  13 #define Max(a, b) ((a)>(b)?(a):(b))
  14 
  15 int T, n, m, p[maxn], v[maxn], f[maxn];
  16 
  17 int main()
  18 {
  19     scanf("%d", &T);
  20     while(T--)
  21     {
  22         memset(f, 0, sizeof f);
  23 
  24         scanf("%d%d", &n, &m);
  25         for(int i=1; i<=n; i++) scanf("%d", &p[i]);
  26         for(int i=1; i<=n; i++) scanf("%d", &v[i]);
  27         
  28         for(int i=1; i<=n; i++)
  29             for(int j=m; j>=v[i]; j--)
  30                 f[j]=Max(f[j], f[j-v[i]]+p[i]);
  31         printf("%d\n", f[m]);
  32     }
  33     return 0;
  34 }
  35 
  36 
  37 
  38 
  39 /**************************************************
  40 
  41             模版：并查集
  42             题目：POJ1182 食物链
  43 
  44 **************************************************/
  45 
  46 #include<iostream>
  47 #include<cstring>
  48 #include<cstdio>
  49 using namespace std;
  50 const int maxn=50000+10;
  51 
  52 int n, m, a[5], b[5], f[maxn*3], p[maxn*3];
  53 
  54 void Pre()
  55 {
  56     for(int i=1; i<=n; i++) p[i]=i, p[i+n]=i+n, p[i+n*2]=i+n*2;
  57     for(int i=1; i<=n; i++) f[i]=i+n, f[i+n]=i+n*2, f[i+n*2]=i;
  58     return ;
  59 }
  60 
  61 int Root(int x)
  62 {
  63     return (x==p[x])?(x):(p[x]=Root(p[x]));
  64 }
  65 
  66 int main()
  67 {
  68     scanf("%d%d", &n, &m);
  69     Pre();
  70 
  71     int d, x, y, ans=0;
  72 
  73     for(int i=1; i<=m; i++)
  74     {
  75         scanf("%d%d%d", &d, &x, &y);
  76 
  77         if(x>n||y>n||(d==2&&x==y))  
  78         {
  79             ++ans;
  80             continue;
  81         }
  82             
  83         a[0]=Root(x), a[1]=f[a[0]], a[2]=f[a[1]];
  84         b[0]=Root(y), b[1]=f[b[0]], b[2]=f[b[1]];
  85             
  86         bool flag=false;
  87         for(int j=0; j<3&&!flag; j++)  if(a[0]==b[j])  flag=true;
  88 
  89         if(d==1)
  90         {
  91             if(flag)    ans+=(a[0]!=b[0]);
  92             else for(int j=0; j<3; j++) p[b[j]]=a[j];
  93         }
  94         else
  95         {
  96             if(flag)    ans+=(a[0]!=b[1]);
  97             else for(int j=0; j<3; j++) p[b[j]]=a[(j+2)%3];
  98         }
  99             
 100     }
 101 
 102     printf("%d\n", ans);
 103     return 0;
 104 }
 105 
 106 
 107 
 108 
 109 /**************************************************
 110 
 111             模版：二分图最大匹配
 112             题目：POJ1274 The Perfect Stall
 113             
 114 **************************************************/
 115 
 116 #include<iostream>
 117 #include<cstring>
 118 #include<cstdio>
 119 using namespace std;
 120 const int maxn=200+10;
 121 
 122 int n, m, ans, from[maxn];
 123 int cur, fir[maxn], ver[maxn*maxn], nxt[maxn*maxn];
 124 bool vis[maxn];
 125 
 126 void Add(int u, int v)
 127 {
 128     ver[++cur]=v, nxt[cur]=fir[u], fir[u]=cur;
 129     return ;
 130 }
 131 
 132 bool Dfs(int u)
 133 {
 134     for(int i=fir[u], v; i; i=nxt[i])
 135     {
 136         if(vis[v=ver[i]])   continue;
 137         vis[v]=true;
 138         
 139         if((!from[v=ver[i]])||Dfs(from[v]))
 140         {
 141             from[v]=u;
 142             return true;
 143         }
 144     }
 145     return false;
 146 }
 147 
 148 int main()
 149 {
 150     while(scanf("%d%d", &n, &m)!=EOF)
 151     {
 152         cur=0, ans=0;
 153         memset(fir, 0, sizeof fir);
 154         memset(from, 0, sizeof from);
 155 
 156         for(int u=1, v, k; u<=n; u++)
 157         {
 158             scanf("%d", &k);
 159             for(int i=1; i<=k; i++)
 160             {
 161                 scanf("%d", &v);
 162                 Add(u, v);
 163             }
 164         }
 165 
 166         for(int i=1; i<=n; i++)
 167         {
 168             memset(vis, 0, sizeof vis);
 169             ans+=Dfs(i);
 170         }
 171 
 172         cout<<ans<<endl;
 173     }
 174     return 0;
 175 }
 176 
 177 
 178 
 179 
 180 /**************************************************
 181 
 182             模版：二分图最佳匹配
 183             题目：POJ2195 Going Home
 184             
 185 **************************************************/
 186 
 187 #include<iostream>
 188 #include<cstring>
 189 #include<cstdio>
 190 #define Min(a, b) ((a)<(b)?(a):(b))
 191 #define Abs(a) ((a)>0?(a):-(a))
 192 using namespace std;
 193 const int maxn=100+10;
 194 const int INF=0x7f7f7f7f;
 195 
 196 int n, m, ch, cm;
 197 int lx[maxn*maxn], ly[maxn], w[maxn*maxn][maxn], from[maxn], del;
 198 bool vx[maxn*maxn], vy[maxn];
 199 struct node
 200 {
 201     int x, y;
 202     node(int a=0, int b=0){ x=a, y=b; }
 203 }ph[maxn], pm[maxn*maxn];
 204 
 205 int Dis(int a, int b)
 206 {
 207     return Abs(pm[a].x-ph[b].x)+Abs(pm[a].y-ph[b].y);
 208 }
 209 
 210 bool Dfs(int x)
 211 {
 212     vx[x]=true;
 213     for(int y=1; y<=ch; y++)
 214     {
 215         if(vy[y])   continue;
 216 
 217         int t=lx[x]+ly[y]-w[x][y];
 218         if(!t)
 219         {
 220             vy[y]=true;
 221             if((!from[y])||Dfs(from[y]))
 222             {
 223                 from[y]=x;
 224                 return true;
 225             }
 226         }
 227         else if(del>t)  del=t;
 228     }
 229     return false;
 230 }
 231 
 232 int KM()
 233 {
 234     for(int i=1; i<=cm; i++)
 235     {
 236         while(true)
 237         {
 238             memset(vx, 0, sizeof vx);
 239             memset(vy, 0, sizeof vy);
 240             del=INF;
 241             if(Dfs(i))  break;
 242             for(int j=1; j<=cm; j++)  if(vx[j])   lx[j]-=del;
 243             for(int j=1; j<=ch; j++)  if(vy[j])   ly[j]+=del;
 244         }
 245     }
 246 
 247     int ans=0;
 248     for(int i=1; i<=ch; i++)    if(from[i])    ans+=w[from[i]][i];
 249     return ans;
 250 }
 251 
 252 int main()
 253 {
 254     int T=0;
 255     while(scanf("%d%d", &n, &m)!=EOF&&n+m)
 256     {
 257         ch=cm=0;
 258         memset(ly, 0, sizeof ly);
 259         memset(from, 0, sizeof from);
 260         char s[maxn];
 261 
 262         for(int i=1; i<=n; i++)
 263         {
 264             scanf("%s", s+1);
 265             for(int j=1; j<=m; j++)
 266             {
 267                 if(s[j]==‘H‘)   ph[++ch]=node(i, j);
 268                 else if(s[j]==‘m‘)  pm[++cm]=node(i, j);
 269             }
 270         }
 271 
 272         for(int i=1; i<=cm; i++)
 273         {
 274             lx[i]=-INF;
 275             for(int j=1; j<=ch; j++)
 276             {
 277                 w[i][j]=-Dis(i, j);
 278                 lx[i]=Min(lx[i], w[i][j]);
 279             }
 280         }
 281         
 282         cout<<-KM()<<endl;
 283     }
 284     return 0;
 285 }
 286 
 287 
 288 
 289 
 290 /**************************************************
 291 
 292             模版：二维树状数组
 293             题目：CQBZ1909 二维区间的和
 294 
 295 **************************************************/
 296 
 297 #include<iostream>
 298 #include<cstdio>
 299 #include<cstring>
 300 #define lowbit(i) ((i)&(-i))
 301 using namespace std;
 302 const int maxn=1500+10;
 303  
 304 int n,a[maxn][maxn];
 305  
 306 void get_int(int &num)
 307 {
 308     char c; bool f=false;
 309     for(; c=getchar(),c<‘0‘||c>‘9‘; (c==‘-‘)&&(f=true));
 310     for(num=c-48; c=getchar(),c>=‘0‘&&c<=‘9‘; num=num*10+c-48);
 311     f&&(num=-num);
 312     return ;
 313 }
 314  
 315 void Add(int x, int y, int t)
 316 {
 317     for(int i=x+1; i<=n; i+=lowbit(i))
 318         for(int j=y+1; j<=n; j+=lowbit(j))
 319             a[i][j]+=t;
 320     return ;
 321 }
 322  
 323 int Sum(int x,int y)
 324 {
 325     int ans=0;
 326     for(int i=x+1; i; i-=lowbit(i))
 327         for(int j=y+1; j; j-=lowbit(j))
 328             ans+=a[i][j];
 329     return ans;
 330 }
 331  
 332 int main()
 333 {
 334     int d, x1, y1, t, x2, y2;
 335  
 336     scanf("%d%d", &d, &n);
 337     while(scanf("%d",&d)&&d!=3)
 338     {
 339         if(d==1)
 340         {
 341             get_int(x1), get_int(y1), get_int(t);
 342             Add(x1,y1,t);
 343         }
 344         else
 345         {
 346             get_int(x1), get_int(y1), get_int(x2), get_int(y2);
 347             printf("%d\n", Sum(x2,y2)+ Sum(x1-1,y1-1)- Sum(x1-1,y2)- Sum(x2,y1-1));
 348         }
 349     }
 350     return 0;
 351 }
 352 
 353 
 354 
 355 
 356 /**************************************************
 357 
 358             模版：高精度
 359             题目：高精度加减乘除
 360 
 361 **************************************************/
 362 
 363 #include<iostream>
 364 #include<fstream>
 365 #include<cstring>
 366 #include<cstdio>
 367 using namespace std;
 368 typedef long long lint;
 369 const int MAXN=5010;
 370 struct node
 371 {
 372     long long n[MAXN],lim;
 373     node(){ memset(n,0,sizeof(n));n[0]=1LL;lim=10000LL; }
 374     bool operator <(node a) const
 375     {
 376         if(n[0]!=a.n[0])    return n[0]<a.n[0];
 377         for(int i=n[0];i>=1;i--)
 378             if(n[i]!=a.n[i])    return n[i]<a.n[i];
 379         return false;
 380     }
 381     bool operator >(node a) const
 382     {
 383         if(n[0]!=a.n[0])    return n[0]>a.n[0];
 384         for(int i=n[0];i>=1;i--)
 385             if(n[i]!=a.n[i])    return n[i]>a.n[i];
 386         return false;
 387     }
 388     bool operator ==(node a) const
 389     {
 390         if(n[0]!=a.n[0])    return false;
 391         for(int i=1;i<=n[0];i++)
 392             if(n[i]!=a.n[i])    return false;
 393         return true;
 394     }
 395     void operator +=(lint a)
 396     {
 397         n[1]+=a;
 398         for(int i=1;i<=n[0];i++)
 399         {
 400             n[i+1]+=(n[i]/lim);
 401             n[i]%=lim;
 402             if(i==n[0]&&n[i+1])  ++n[0];
 403         }
 404     }
 405     node operator +(lint a)
 406     {
 407         node t=*this;
 408         t+=a;
 409         return t;
 410     }
 411     void operator +=(node a)
 412     {
 413         n[0]=max(n[0],a.n[0]);
 414         for(int i=1;i<=n[0];i++)    n[i]+=a.n[i];
 415         for(int i=1;i<=n[0];i++)
 416         {
 417             n[i+1]+=(n[i]/lim);
 418             n[i]%=lim;
 419             if(i==n[0]&&n[i+1]) ++n[0];
 420         }
 421     }
 422     node operator +(node a)
 423     {
 424         node t=*this;
 425         t+=a;
 426         return t;
 427     }
 428     void operator -=(lint a)
 429     {
 430         n[1]-=a;
 431         for(int i=1;n[i]<0&&i<n[0];i++)
 432             while(n[i]<0)   n[i]+=lim,n[i+1]-=1;
 433         for(;!n[n[0]]&&n[0]>1;--n[0]);
 434     }
 435     node operator -(lint a)
 436     {
 437         node t=*this;
 438         t-=a;
 439         return t;
 440     }
 441     void operator -=(node a)
 442     {
 443         for(int i=1;i<=n[0];i++)
 444         {
 445             if(n[i]<a.n[i]) n[i]+=lim,n[i+1]-=1;
 446             n[i]-=a.n[i];
 447         }
 448         for(;!n[n[0]]&&n[0]>1;--n[0]);
 449     }
 450     node operator -(node a)
 451     {
 452         node t=*this;
 453         t-=a;
 454         return t;
 455     }
 456     void operator *=(lint a)
 457     {
 458         for(int i=1;i<=n[0];i++)    n[i]*=a;
 459         for(int i=1;i<=n[0];i++)
 460         {
 461             n[i+1]+=(n[i]/lim);
 462             n[i]%=lim;
 463             if(i==n[0]&&n[i+1]) ++n[0];
 464         }
 465     }
 466     node operator *(lint a)
 467     {
 468         node t=*this;
 469         t*=a;
 470         return t;
 471     }
 472     void operator *=(node a)
 473     {
 474         node c;
 475         c.n[0]=n[0]+a.n[0]-1;
 476         for(int i=1;i<=n[0];i++)
 477             for(int j=1;j<=a.n[0];j++)
 478                 c.n[i+j-1]+=n[i]*a.n[j];
 479         for(int i=1;i<=c.n[0];i++)
 480         {
 481             c.n[i+1]+=(c.n[i]/lim);
 482             c.n[i]%=lim;
 483             if(i==c.n[0]&&c.n[i+1]) ++c.n[0];
 484         }
 485         *this=c;
 486     }
 487     node operator *(node a)
 488     {
 489         node t=*this;
 490         t*=a;
 491         return t;
 492     }
 493     void operator /=(lint a)
 494     {
 495         for(int i=n[0];i>1;i--)
 496         {
 497             n[i-1]+=(n[i]%a*lim);
 498             n[i]/=a;
 499         }
 500         for(n[1]/=a;n[0]>1&&!n[n[0]];--n[0]);
 501     }
 502     node operator /(lint a)
 503     {
 504         node t=*this;
 505         t/=a;
 506         return t;
 507     }
 508     void operator /=(node a)
 509     {
 510         node L,M,R=*this;
 511         while(L<R)
 512         {
 513             M=(L+R+1)/2;
 514             if((a*M)>*this) R=M-1;
 515             else L=M;
 516         }
 517         *this=L;
 518     }
 519     node operator /(node a)
 520     {
 521         node t=*this;
 522         t/=a;
 523         return t;
 524     }
 525     void read()
 526     {
 527         string s;
 528         cin>>s;
 529         n[0]=s.size();
 530         for(int i=0,j;j=(n[0]-i-1)/4+1,i<n[0];i++)  n[j]=n[j]*10+s[i]-‘0‘;
 531         if(n[0]%4)  n[0]=n[0]/4+1;
 532         else n[0]/=4;
 533     }
 534     void put()
 535     {
 536         int i=n[0];
 537         cout<<n[i];
 538         for(--i;i;--i)  printf("%04lld",n[i]);
 539         cout<<endl;
 540     }
 541 }a,b,c;
 542 node Gcd(node a,node b)
 543 {
 544     if(a.n[0]==1&&a.n[1]==0)  return b;
 545     if(b.n[0]==1&&b.n[1]==0)  return a;
 546     if((a.n[1]&1)&&(b.n[1]&1))  return ((a>b)?(Gcd(a-b,b)):(b-a,a));
 547     if(a.n[1]&1)  return Gcd(a,b/2);
 548     if(b.n[1]&1)  return Gcd(a/2,b);
 549     return Gcd(a/2,b/2)*2;
 550 }
 551 int main()
 552 {
 553     //加
 554     /*
 555     a.read();
 556     b.read();
 557     a+=b;
 558     a.put();
 559     */
 560  
 561     //减
 562     /*
 563     a.read();
 564     b.read();
 565     if(a<b) { cout<<‘-‘; c=b-a;}
 566     else c=a-b;
 567     c.put();
 568     */
 569  
 570     //乘
 571     /*
 572     a.read();
 573     b.read();
 574     a*=b;
 575     a.put();
 576     */
 577  
 578     //除
 579      
 580     a.read();
 581     b.read();
 582     c=a;
 583     a/=b;
 584     a.put();
 585     a*=b;
 586     c-=a;
 587     c.put();
 588      
 589     return 0;
 590 }
 591 
 592 
 593 
 594 
 595 /**************************************************
 596 
 597             模版：Manacher
 598             题目：POJ3974 Palindrome
 599             
 600 **************************************************/
 601 
 602 #include<iostream>
 603 #include<cstring>
 604 #include<cstdio>
 605 using namespace std;
 606 const int maxn=1000000*2+10;
 607 #define Max(a, b) ((a)>(b)?(a):(b))
 608 #define Min(a, b) ((a)<(b)?(a):(b))
 609 
 610 int main()
 611 {
 612     int T=0;
 613     string t;
 614     while(cin>>t)
 615     {
 616         if(t[0]==‘E‘)   break;
 617 
 618         string s="!*";
 619         for(int i=0, j=t.size(); i<j; i++)  s+=t[i], s+=‘*‘;
 620         
 621         int f[maxn]={0}, n=s.size();
 622         int id=0, mx=0, ans=0;
 623         for(int i=1; i<n; i++)
 624         {
 625             f[i]= (mx>i)? Min(f[id*2-i], mx-i): 1;
 626             while(s[i-f[i]]==s[i+f[i]])  ++f[i];
 627             ans=Max(ans, f[i]);
 628             if(i+f[i]>mx)   mx=i+f[i], id=i;
 629         }
 630 
 631         printf("Case %d: %d\n", ++T, ans-1);
 632     }
 633     return 0;
 634 }
 635 
 636 
 637 
 638 
 639 /**************************************************
 640 
 641             模版：欧拉路径
 642             题目：HDU1116 play on words
 643 
 644 **************************************************/
 645 
 646 #include<iostream>
 647 #include<cstring>
 648 #include<cstdio>
 649 using namespace std;
 650 const int maxn=26+5;
 651 
 652 int T, n, fa[maxn], in[maxn], out[maxn];
 653 
 654 int Rt(int x)
 655 {
 656     return (x==fa[x])?(x):(fa[x]=Rt(fa[x]));
 657 }
 658 
 659 void Init()
 660 {
 661     memset(in, 0, sizeof in);
 662     memset(out, 0, sizeof out);
 663     for(int i=0; i<26; i++) fa[i]=i;
 664     return ;
 665 }
 666 
 667 bool Read()
 668 {
 669     scanf("%d", &n);
 670     
 671     string s;
 672     int a, b;
 673     for(int i=1; i<=n; i++)
 674     {
 675         cin>>s;
 676         a=s[0]-‘a‘, b=s[s.size()-1]-‘a‘;
 677         ++in[a], ++out[b];
 678         fa[Rt(b)]=Rt(a);
 679     }
 680     
 681     a=Rt(a);
 682     for(int i=0; i<26; i++)
 683         if((in[i]||out[i])&&Rt(i)!=a)
 684             return false;
 685     return true;
 686 }
 687 
 688 bool Work()
 689 {
 690     int _in=0, _out=0;
 691     for(int i=0; i<26; i++)
 692     {
 693         if(in[i]==out[i])   continue;
 694         else if(in[i]==out[i]+1) ++_in;
 695         else if(in[i]+1==out[i]) ++_out;
 696         else return false;
 697     }
 698     return (_in==_out)&&(_in<2);
 699 }
 700 
 701 int main()
 702 {
 703     scanf("%d", &T);
 704     while(T--)
 705     {
 706         Init();
 707         if(Read()&&Work())  printf("Ordering is possible.\n");
 708         else printf("The door cannot be opened.\n");
 709     }
 710     return 0;
 711 }
 712 
 713 
 714 
 715 
 716 /**************************************************
 717 
 718             模版：欧拉路径输出
 719             题目：POJ2337 catenyms
 720 
 721 **************************************************/
 722 
 723 #include<iostream>
 724 #include<algorithm>
 725 #include<cstring>
 726 #include<cstdio>
 727 using namespace std;
 728 const int maxn=1000+10, maxm=26+5;
 729 #define Min(a, b) ((a)<(b)?(a):(b))
 730 
 731 int T, n, in[maxm], out[maxm], fa[maxm], root, put[maxn];
 732 string s[maxn];
 733 bool vis[maxn];
 734 
 735 int Rt(int x)
 736 {
 737     return (x==fa[x])?(x):(fa[x]=Rt(fa[x]));
 738 }
 739 
 740 void Init()
 741 {
 742     root=maxm;
 743     memset(in, 0, sizeof in);
 744     memset(out, 0, sizeof out);
 745     memset(vis, false, sizeof vis);
 746     for(int i=0; i<26; i++) fa[i]=i;
 747     return ;
 748 }
 749 
 750 bool Read()
 751 {
 752     scanf("%d", &n);
 753 
 754     int a, b;
 755     for(int i=1; i<=n; i++)
 756     {
 757         cin>>s[i];
 758         a=s[i][0]-‘a‘, b=s[i][s[i].size()-1]-‘a‘;
 759         ++in[a], ++out[b];
 760         root=Min(root, a);
 761         fa[Rt(b)]=Rt(a);
 762     }
 763 
 764     a=Rt(a);
 765     for(int i=0; i<26; i++)
 766         if((in[i]||out[i])&&Rt(i)!=a)
 767             return false;
 768     return true;
 769 }
 770 
 771 bool Work()
 772 {
 773     int _in=0, _out=0;
 774     for(int i=0; i<26; i++)
 775     {
 776         if(in[i]==out[i])   continue;
 777         else if(in[i]==out[i]+1) ++_in, root=i;
 778         else if(in[i]+1==out[i]) ++_out;
 779         else return false;
 780     }
 781     return (_in==_out)&&(_in<2);
 782 }
 783 
 784 bool Dfs(int x, int cnt)
 785 {
 786     for(int i=1; i<=n; i++)
 787         if((!vis[i])&&s[i][0]-‘a‘==x)
 788         {
 789             vis[i]=true;
 790             put[cnt]=i;
 791             if(cnt==n||Dfs(s[i][s[i].size()-1]-‘a‘, cnt+1)) return true;
 792             vis[i]=false;
 793         }
 794     return false;
 795 }
 796 
 797 int main()
 798 {
 799     scanf("%d", &T);
 800     while(T--)
 801     {
 802         Init();
 803         if(Read()&&Work())
 804         {
 805             sort(s+1, s+1+n);
 806             Dfs(root, 1);
 807             for(int i=1; i<n; i++)  cout<<s[put[i]]<<‘.‘;
 808             cout<<s[put[n]]<<endl;
 809         }
 810         else printf("***\n");
 811     }
 812     return 0;
 813 }
 814 
 815 
 816 
 817 
 818 /**************************************************
 819 
 820             模版：Avl
 821             题目：POJ3481 Double Queue
 822 
 823 **************************************************/
 824 
 825 #include<iostream>
 826 #include<cstring>
 827 #include<cstdio>
 828 using namespace std;
 829 const int maxn=(1e6)+10;
 830 #define Max(a, b) ((a)>(b)?(a):(b))
 831 
 832 int root, cnt;
 833 
 834 struct node
 835 {
 836     int val, idx, lc, rc, h;
 837     node() { val=idx=lc=rc=h=0; }
 838 }tr[maxn];
 839 
 840 void Zig(int &rt)
 841 {
 842     int tp=tr[rt].lc;
 843     tr[rt].lc=tr[tp].rc;
 844     tr[tp].rc=rt;
 845     tr[rt].h=Max(tr[tr[rt].lc].h, tr[tr[rt].rc].h)+1;
 846     tr[tp].h=Max(tr[tr[tp].lc].h, tr[tr[tp].rc].h)+1;
 847     rt=tp;
 848     return ;
 849 }
 850 
 851 void Zag(int &rt)
 852 {
 853     int tp=tr[rt].rc;
 854     tr[rt].rc=tr[tp].lc;
 855     tr[tp].lc=rt;
 856     tr[rt].h=Max(tr[tr[rt].lc].h, tr[tr[rt].rc].h)+1;
 857     tr[tp].h=Max(tr[tr[tp].lc].h, tr[tr[tp].rc].h)+1;
 858     rt=tp;
 859     return ;
 860 }
 861 
 862 void Zagzig(int &rt)
 863 {
 864     Zag(tr[rt].lc);
 865     Zig(rt);
 866     return ;
 867 }
 868 
 869 void Zigzag(int &rt)
 870 {
 871     Zig(tr[rt].rc);
 872     Zag(rt);
 873     return ;
 874 }
 875 
 876 void Maintain(int &rt)
 877 {
 878     if(tr[tr[rt].lc].h==tr[tr[rt].rc].h+2)
 879     {
 880         if(tr[tr[rt].lc].h==tr[tr[tr[rt].lc].lc].h+1)   Zig(rt);
 881         else Zagzig(rt);
 882     }
 883     else if(tr[tr[rt].lc].h+2==tr[tr[rt].rc].h)
 884     {
 885         if(tr[tr[rt].rc].h==tr[tr[tr[rt].rc].rc].h+1)   Zag(rt);
 886         else Zigzag(rt);
 887     }
 888     return ;
 889 }
 890 
 891 void Insert(int &rt, int val, int idx)
 892 {
 893     if(!rt)
 894     {
 895         tr[rt=++cnt].h=1;
 896         tr[rt].val=val, tr[rt].idx=idx;
 897         return ;
 898     }
 899     
 900     if(idx<tr[rt].idx)  Insert(tr[rt].lc, val, idx);
 901     else    Insert(tr[rt].rc, val, idx);
 902     
 903     Maintain(rt);
 904 
 905     return ;
 906 }
 907 
 908 int Delete(int &rt, int d)
 909 {
 910     int ans=0;
 911     if(!rt) ans=0;
 912     else if(!d)
 913     {
 914         if(!tr[rt].lc)
 915         {
 916             ans=tr[rt].val;
 917             rt=tr[rt].rc;
 918         }
 919         else
 920         {
 921             ans=Delete(tr[rt].lc, d);
 922             Maintain(rt);
 923         }
 924     }
 925     else if(d==1)
 926     {
 927         if(!tr[rt].rc)
 928         {
 929             ans=tr[rt].val;
 930             rt=tr[rt].lc;
 931         }
 932         else
 933         {
 934             ans=Delete(tr[rt].rc, d);
 935             Maintain(rt);
 936         }
 937     }
 938     return ans;
 939 }
 940 
 941 int main()
 942 {
 943     int d, val, idx;
 944     while(scanf("%d", &d)!=EOF&&d)
 945     {
 946         if(d==2)    printf("%d\n", Delete(root, 1));
 947         else if(d==3)   printf("%d\n", Delete(root, 0));
 948         else
 949         {
 950             scanf("%d%d", &val, &idx);
 951             Insert(root, val, idx);
 952         }
 953     }
 954     return 0;
 955 }
 956 
 957 
 958 
 959 
 960 /**************************************************
 961 
 962             模版：Tarjan
 963             题目：POJ1236 Network of Schools
 964             
 965 **************************************************/
 966 
 967 #include<iostream>
 968 #include<cstring>
 969 #include<cstdio>
 970 #include<stack>
 971 #define Min(a, b) ((a)<(b)?(a):(b))
 972 #define Max(a, b) ((a)>(b)?(a):(b))
 973 using namespace std;
 974 const int maxn=100+10;
 975 
 976 int n, ans1, ans2, tot, w[maxn];
 977 int cur, fir[maxn], nxt[maxn*maxn], ver[maxn*maxn];
 978 int idx, dfn[maxn], low[maxn];
 979 bool ins[maxn], in[maxn], out[maxn];
 980 stack<int> s;
 981 
 982 void Add(int x, int y)
 983 {
 984     ver[++cur]=y, nxt[cur]=fir[x], fir[x]=cur;
 985     return ;
 986 }
 987 
 988 void Tarjan(int u)
 989 {
 990     dfn[u]=low[u]=++idx;
 991     ins[u]=true;
 992     s.push(u);
 993 
 994     for(int i=fir[u], v; i; i=nxt[i])
 995         if(!dfn[v=ver[i]])
 996         {
 997             Tarjan(v);
 998             low[u]=Min(low[u], low[v]);
 999         }
1000         else if(ins[v]) low[u]=Min(low[u], low[v]);
1001 
1002     if(dfn[u]==low[u])
1003     {
1004         int v=s.top();
1005         s.pop();
1006 
1007         w[v]=++tot, ins[v]=false;
1008         while(v!=u)
1009         {
1010             v=s.top();
1011             s.pop();
1012             w[v]=tot, ins[v]=false;
1013         }
1014     }
1015     return ;
1016 }
1017 
1018 int main()
1019 {
1020     scanf("%d", &n);
1021     for(int i=1, j; i<=n; i++)  while(scanf("%d", &j)&&j)   Add(i, j);
1022     
1023     for(int i=1; i<=n; i++) if(!dfn[i]) Tarjan(i);
1024     
1025     for(int i=1; i<=n; i++)
1026         for(int k=fir[i], j; k; k=nxt[k])
1027         {
1028             if(w[i]==w[j=ver[k]])   continue;
1029             in[w[j]]=out[w[i]]=true;
1030         }
1031 
1032     for(int i=1; i<=tot; i++)   ans1+=(!in[i]), ans2+=(!out[i]);
1033 
1034     if(tot==1)  printf("1\n0\n");
1035     else printf("%d\n%d\n", ans1, Max(ans1, ans2));
1036     return 0;
1037 }
1038 
1039 
1040 
1041 
1042 /**************************************************
1043 
1044             模版：线段树
1045             题目：HDU1698 just a hook
1046 
1047 **************************************************/
1048 
1049 #include<iostream>
1050 #include<cstdio>
1051 #define kl (k<<1)
1052 #define kr ((k<<1)+1)
1053 #define mid ((l+r)>>1)
1054 using namespace std;
1055 const int maxn=100000+10;
1056 
1057 int T, n, m;
1058 struct node
1059 {
1060     int sum, col;
1061 }tr[maxn<<2];
1062 
1063 void Build(int k=1, int l=1, int r=n)
1064 {
1065     tr[k].col=1, tr[k].sum=r-l+1;
1066     if(l==r)    return ;
1067     Build(kl, l, mid);
1068     Build(kr, mid+1, r);
1069     return ;
1070 }
1071 
1072 void Push_down(int k, int l, int r)
1073 {
1074     if(tr[k].col)
1075     {
1076         tr[kl].col=tr[kr].col=tr[k].col;
1077         tr[kl].sum=tr[kl].col*(mid-l+1);
1078         tr[kr].sum=tr[kr].col*(r-mid);
1079         tr[k].col=0;
1080     }
1081     return ;
1082 }
1083 
1084 void Push_up(int k)
1085 {
1086     tr[k].sum=tr[kl].sum+tr[kr].sum;
1087     return ;
1088 }
1089 
1090 void Insert(int ll, int rr, int num, int k=1, int l=1, int r=n)
1091 {
1092     if(rr <l||r< ll) return ;
1093     if(ll<=l&&r<=rr)
1094     {
1095         tr[k].col=num, tr[k].sum=(r-l+1)*num;
1096         return ;
1097     }
1098     Push_down(k, l, r);
1099     Insert(ll, rr, num, kl, l, mid);
1100     Insert(ll, rr, num, kr, mid+1, r);
1101     Push_up(k);
1102     return ;
1103 }
1104 
1105 int main()
1106 {
1107     scanf("%d", &T);
1108     for(int j=1; j<=T; j++)
1109     {
1110         scanf("%d%d", &n, &m);
1111         Build();
1112 
1113         for(int i=1, x, y, z; i<=m; i++)
1114         {
1115             scanf("%d%d%d", &x, &y, &z);
1116             Insert(x, y, z);
1117         }
1118 
1119         printf("Case %d: The total value of the hook is %d.\n", j, tr[1].sum);
1120     }
1121     return 0;
1122 }
1123 
1124 
1125 
1126 
1127 /**************************************************
1128 
1129             模版：线段树开区间
1130             题目：URAL1019 Line Painting
1131 
1132 **************************************************/
1133 
1134 #include<iostream>
1135 #include<cstring>
1136 #include<cstdio>
1137 #include<cstdlib>
1138 #include<algorithm>
1139 using namespace std;
1140 const int maxn=5000+10;
1141 #define kl (k<<1)
1142 #define kr ((k<<1)+1)
1143 #define mid ((l+r)>>1)
1144 
1145 int n, m, h[maxn*8];
1146 struct Query
1147 {
1148     int x, y; bool cl;
1149     void Push(int a, int b, bool c) { x=a, y=b, cl=c; }
1150 }q[maxn];
1151 struct node
1152 {
1153     int cl, from, tot, ls, rs;
1154 }tr[maxn*8];
1155 
1156 void Build(int k=1, int l=1, int r=n)
1157 {
1158     if(l>=r)    return ;
1159     tr[k].cl=1, tr[k].from=h[l], tr[k].tot=tr[k].ls=tr[k].rs=h[r]-h[l];
1160     if(l+1==r)  return ;
1161     Build(kl, l, mid);
1162     Build(kr, mid, r);
1163     return ;
1164 }
1165 
1166 void Push_down(int k, int l, int r)
1167 {
1168     if(tr[k].cl!=-1)
1169     {
1170         tr[kl].cl=tr[kr].cl=tr[k].cl, tr[kl].from=h[l], tr[kr].from=h[mid];
1171         tr[kl].tot=tr[kl].ls=tr[kl].rs=tr[kl].cl*(h[mid]-h[l]);
1172         tr[kr].tot=tr[kr].ls=tr[kr].rs=tr[kr].cl*(h[r]-h[mid]);
1173     }
1174     return ;
1175 }
1176 
1177 void Push_up(int k, int l, int r)
1178 {
1179     if(tr[kl].cl!=-1&&tr[kl].cl==tr[kr].cl)
1180         tr[k].cl=tr[kl].cl, tr[k].from=h[l], tr[k].tot=tr[k].ls=tr[k].rs=tr[kl].cl*(h[r]-h[l]);
1181     else
1182     {
1183         tr[k].cl=-1, tr[k].from=tr[kl].from, tr[k].tot=tr[kl].tot, tr[k].ls=tr[kl].ls, tr[k].rs=tr[kr].rs;
1184         if(tr[kl].rs+tr[kr].ls>tr[k].tot)   tr[k].from=h[mid]-tr[kl].rs, tr[k].tot=tr[kl].rs+tr[kr].ls;
1185         if(tr[kr].tot>tr[k].tot)    tr[k].from=tr[kr].from, tr[k].tot=tr[kr].tot;
1186         if(tr[kl].ls==h[mid]-h[l])  tr[k].ls+=tr[kr].ls;
1187         if(tr[kr].rs==h[r]-h[mid])  tr[k].rs+=tr[kl].rs;
1188     }
1189     return ;
1190 }
1191 
1192 void Insert(int ll, int rr, bool cl, int k=1, int l=1, int r=n)
1193 {
1194     if(rr <l||r< ll)    return ;
1195     if(ll<=l&&r<=rr)
1196     {
1197         tr[k].cl=cl, tr[k].from=h[l], tr[k].tot=tr[k].ls=tr[k].rs=cl*(h[r]-h[l]);
1198         return ;
1199     }
1200     if(l+1>=r)  return ;
1201     Push_down(k, l, r);
1202     Insert(ll, rr, cl, kl, l, mid);
1203     Insert(ll, rr, cl, kr, mid, r);
1204     Push_up(k, l, r);
1205     return ;
1206 }
1207 
1208 int main()
1209 {
1210     while(scanf("%d", &m)!=EOF)
1211     {
1212         n=0;
1213         h[++n]=0, h[++n]=1e9;
1214 
1215         int x, y; char c[5];
1216         for(int i=1; i<=m; i++)
1217         {
1218             scanf("%d%d%s", &x, &y, c);
1219             h[++n]=x, h[++n]=y;
1220             q[i].Push(x, y, c[0]==‘w‘);
1221         }
1222 
1223         sort(h+1, h+1+n);
1224         n=unique(h+1, h+1+n)-(h+1);
1225         Build();
1226         
1227         for(int i=1; i<=m; i++)
1228         {
1229             q[i].x=lower_bound(h+1, h+1+n, q[i].x)-h;
1230             q[i].y=lower_bound(h+1, h+1+n, q[i].y)-h;
1231             Insert(q[i].x, q[i].y, q[i].cl);
1232         }
1233 
1234         printf("%d %d\n", tr[1].from, tr[1].from+tr[1].tot);
1235     }
1236     return 0;
1237 }
1238 
1239 
1240 
1241 
1242 /**************************************************
1243 
1244             模版：EXKMP
1245             题目：HDU4333 Revolving Digits
1246 
1247 **************************************************/
1248 
1249 #include<iostream>
1250 #include<cstring>
1251 #include<cstdio>
1252 using namespace std;
1253 const int maxn=200000+10;
1254 #define Max(a, b) ((a)>(b)?(a):(b))
1255 
1256 int T, n, m, nx[maxn], ex[maxn];
1257 char t[maxn], s[maxn];
1258 
1259 void Read()
1260 {
1261     scanf("%s", t);
1262     n=strlen(t);
1263 
1264     for(int i=0; i<n; i++)  s[i]=s[n+i]=t[i];
1265     m=n+n;
1266     
1267     memset(nx, 0, sizeof nx);
1268     memset(ex, 0, sizeof ex);
1269     return ;
1270 }
1271 
1272 void Exkmp()
1273 {
1274     nx[0]=n;
1275     for(int i=1; i<n; i++)
1276     {
1277         if(t[i]!=t[i-1])    break;
1278         nx[1]=i;
1279     }
1280     for(int i=2, j, k=1, p, w; i<n; i++)
1281     {
1282         p=k+nx[k]-1, w=nx[i-k];
1283         if(i+w<p+1) nx[i]=w;
1284         else
1285         {
1286             j=Max(p-i+1, 0);
1287             while(i+j<n && t[i+j]==t[j])    ++j;
1288             nx[i]=j, k=i;
1289         }
1290     }
1291 
1292     for(int i=0; i<n&&i<m; i++)
1293     {
1294         if(s[i]!=t[i])  break;
1295         ex[0]=i+1;
1296     }
1297     for(int i=1, j, k=0, p, w; i<m; i++)
1298     {
1299         p=k+ex[k]-1, w=nx[i-k];
1300         if(i+w<p+1) ex[i]=w;
1301         else
1302         {
1303             j=Max(p-i+1, 0);
1304             while(i+j<m && j<n && s[i+j]==t[j]) ++j;
1305             ex[i]=j, k=i;
1306         }
1307     }
1308     return ;
1309 }
1310 
1311 int Kmp()
1312 {
1313     nx[0]=0;
1314     for(int j=0, i=1; i<n; i++)
1315     {
1316         while(j && t[j]!=t[i])  j=nx[j-1];
1317         if(t[j]==t[i])  ++j;
1318         nx[i]=j;
1319     }
1320     return nx[n-1];
1321 }
1322 
1323 void Work()
1324 {
1325     int le=0, eq=0, gr=0;
1326     Exkmp();
1327 
1328     for(int i=0; i<n; i++)
1329     {
1330         if(ex[i]==n)    ++eq;
1331         else
1332         {
1333             if(s[i+ex[i]]>t[ex[i]]) ++gr;
1334             else ++le;
1335         }
1336     }
1337 
1338     int tmp=n-Kmp();
1339     int cnt=(n%tmp)?(1):(n/tmp);
1340     printf(" %d %d %d\n", le/cnt, eq/cnt, gr/cnt);
1341     return ;
1342 }
1343 
1344 int main()
1345 {
1346     scanf("%d", &T);
1347     for(int i=1; i<=T; i++)
1348     {
1349         printf("Case %d:", i);
1350         Read(), Work();
1351     }
1352     return 0;
1353 }
1354 
1355 
1356 
1357 
1358 /**************************************************
1359 
1360             模版：KMP
1361             题目：HDU1711 Number Sequence
1362 
1363 **************************************************/
1364 
1365 #include<iostream>
1366 #include<cstring>
1367 #include<cstdio>
1368 using namespace std;
1369 const int maxn=1000000+10;
1370 
1371 int T, n, m, a[maxn], b[maxn];
1372 int nx[maxn], ex[maxn];
1373 
1374 int Kmp()
1375 {
1376     nx[0]=0;
1377     for(int i=1, j=0; i<m; i++)
1378     {
1379         while(j&&b[j]!=b[i])    j=nx[j-1];
1380         if(b[j]==b[i])  ++j;
1381         nx[i]=j;
1382     }
1383     
1384     for(int i=0, j=0; i<n; i++)
1385     {
1386         while(j&&b[j]!=a[i])    j=nx[j-1];
1387         if(b[j]==a[i])  ++j;
1388         if(j==m)    return i-m+2;
1389     }
1390 
1391     return -1;
1392 }
1393 
1394 int main()
1395 {
1396     scanf("%d", &T);
1397     while(T--)
1398     {
1399         scanf("%d%d", &n, &m);
1400         for(int i=0; i<n; i++)  scanf("%d", &a[i]);
1401         for(int i=0; i<m; i++)  scanf("%d", &b[i]);
1402 
1403         printf("%d\n", Kmp());
1404     }
1405     return 0;
1406 }
1407 
1408 
1409 
1410 
1411 /**************************************************
1412 
1413             模版：最短路Dijkastra
1414             题目：HDU2544 最短路
1415             注意：针对正权图
1416 
1417 **************************************************/
1418 
1419 #include<iostream>
1420 #include<cstring>
1421 #include<cstdio>
1422 using namespace std;
1423 const int maxn=100+10;
1424 
1425 int n, m, d[maxn][maxn], s[maxn];
1426 bool vis[maxn];
1427 
1428 void Read()
1429 {
1430     memset(s, 0xf, sizeof s);
1431     memset(d, 0xf, sizeof d);
1432     memset(vis, false, sizeof vis);
1433 
1434     for(int i=1, u, v, c; i<=m; i++)
1435     {
1436         scanf("%d%d%d", &u, &v, &c);
1437         d[u][v]=d[v][u]=c;
1438     }
1439     return ;
1440 }
1441 
1442 void Work()
1443 {
1444     int S=1, T=n, u=1, v, cur, cnt=0;
1445     s[S]=0;
1446     while(cnt++<n)
1447     {
1448         vis[u]=true;
1449         for(int i=1; i<=n; i++)
1450         {
1451             if(vis[i])  continue;
1452             if(s[i]>s[u]+d[u][i])    s[i]=s[u]+d[u][i];
1453             if(s[i]<cur)    cur=s[i], v=i;
1454         }
1455         u=v, cur=s[0];
1456     }
1457     printf("%d\n", s[T]);
1458     return ;
1459 }
1460 
1461 int main()
1462 {
1463     while(scanf("%d%d", &n, &m)!=EOF&&n+m)   Read(), Work();
1464     return 0;
1465 }
1466 
1467 
1468 
1469 
1470 /**************************************************
1471 
1472             模版：最短路Floyd
1473             题目：HDU2544 最短路
1474 
1475 **************************************************/
1476 
1477 #include<iostream>
1478 #include<cstring>
1479 #include<cstdio>
1480 using namespace std;
1481 const int maxn=100+10;
1482 #define Min(a, b) ((a)<(b)?(a):(b))
1483 int n, m, d[maxn][maxn];
1484 
1485 void Read()
1486 {
1487     memset(d, 0xf, sizeof d);
1488     for(int i=1, u, v, c; i<=m; i++)
1489     {
1490         scanf("%d%d%d", &u, &v, &c);
1491         d[u][v]=d[v][u]=c;
1492     }
1493     return ;
1494 }
1495 
1496 void Work()
1497 {
1498     for(int k=1; k<=n; k++)
1499         for(int i=1; i<=n; i++)
1500             for(int j=1; j<=n; j++)
1501                 if(i!=j&&j!=k&&i!=k)
1502                     d[i][j]=Min(d[i][j], d[i][k]+d[k][j]);
1503     printf("%d\n", d[1][n]);
1504     return ;
1505 }
1506 
1507 int main()
1508 {
1509     while(scanf("%d%d", &n, &m)!=EOF&&n+m)  Read(), Work();
1510     return 0;
1511 }
1512 
1513 
1514 
1515 
1516 /**************************************************
1517 
1518             模版：最短路SPFA
1519             题目：HDU2544 最短路
1520             注意：可用于负权图
1521 
1522 **************************************************/
1523 
1524 #include<iostream>
1525 #include<cstring>
1526 #include<cstdio>
1527 #include<queue>
1528 using namespace std;
1529 const int maxn=100+10;
1530 
1531 int n, m, S, T, d[maxn][maxn], s[maxn];
1532 bool vis[maxn];
1533 queue<int> q;
1534 
1535 void Read()
1536 {
1537     memset(d, 0xf, sizeof d);
1538     memset(s, 0xf, sizeof s);
1539     for(int i=1, u, v, c; i<=m; i++)
1540     {
1541         scanf("%d%d%d", &u, &v, &c);
1542         d[u][v]=d[v][u]=c;
1543     }
1544     return ;
1545 }
1546 
1547 void Work()
1548 {
1549     s[S=1]=0, T=n;
1550 
1551     q.push(S), vis[S]=true;
1552     
1553     while(!q.empty())
1554     {
1555         int u=q.front();
1556 
1557         for(int i=1; i<=n; i++)
1558             if(s[i]>s[u]+d[u][i])
1559             {
1560                 s[i]=s[u]+d[u][i];
1561                 if(!vis[i]) q.push(i), vis[i]=true;
1562             }
1563         
1564         q.pop(), vis[u]=false;
1565     }
1566 
1567     printf("%d\n", s[T]);
1568     return ;
1569 }
1570 
1571 int main()
1572 {
1573     while(scanf("%d%d", &n, &m)!=EOF&&n+m)   Read(), Work();
1574     return 0;
1575 }
1576 
1577 
1578 
1579 
1580 
1581 /**************************************************
1582 
1583             模版：最小生成树Kuskal
1584             题目：POJ1258 Agri-Net
1585 
1586 **************************************************/
1587 
1588 #include<iostream>
1589 #include<cstdio>
1590 #include<queue>
1591 using namespace std;
1592 const int maxn=100+10;
1593 
1594 int n, fa[maxn], d[maxn][maxn];
1595 struct node
1596 {
1597     int u, v, c;
1598     bool operator <(const node&a)const { return c>a.c; }
1599 }p;
1600 priority_queue<node> q;
1601 
1602 void Read()
1603 {
1604     for(int i=1; i<=n; i++)
1605         for(int j=1; j<=n; j++)
1606             scanf("%d", &d[i][j]);
1607 
1608     while(!q.empty())   q.pop();
1609     for(int i=1; i<=n; i++)
1610         for(int j=i+1; j<=n; j++)
1611         {
1612             p.u=i, p.v=j, p.c=d[i][j];
1613             q.push(p);
1614         }
1615     return ;
1616 }
1617 
1618 int Rt(int x)
1619 {
1620     return (x==fa[x])?(x):(fa[x]=Rt(fa[x]));
1621 }
1622 
1623 void Work()
1624 {
1625     for(int i=1; i<=n; i++) fa[i]=i;
1626 
1627     int ans=0, cnt=1;
1628     while(cnt<n)
1629     {
1630         int u=Rt(q.top().u), v=Rt(q.top().v), c=q.top().c;
1631         q.pop();
1632         if(u==v)    continue;
1633         ++cnt, ans+=c;
1634         if(u<v) fa[v]=u;
1635         else fa[u]=v;
1636     }
1637 
1638     printf("%d\n", ans);
1639     return ;
1640 }
1641 
1642 int main()
1643 {
1644     while(scanf("%d", &n)!=EOF) Read(), Work();
1645     return 0;
1646 }
1647 
1648 
1649 
1650 
1651 /**************************************************
1652 
1653             模版：最小生成树Prim
1654             题目：POJ1258 Agri-Net
1655 
1656 **************************************************/
1657 
1658 #include<iostream>
1659 #include<cstring>
1660 #include<cstdio>
1661 using namespace std;
1662 const int maxn=100+10;
1663 
1664 int n, d[maxn][maxn], _min[maxn];
1665 bool vis[maxn];
1666 
1667 void Read()
1668 {
1669     for(int i=1; i<=n; i++)
1670         for(int j=1; j<=n; j++)
1671             scanf("%d", &d[i][j]);
1672     return ;
1673 }
1674 
1675 void Work()
1676 {
1677     memset(vis, false, sizeof vis);
1678     memset(_min, 0xf, sizeof _min);
1679 
1680     int u=1, v, cur=_min[0], cnt=1, ans=0;
1681     while(cnt++<n)
1682     {
1683         vis[u]=true;
1684         for(int i=1; i<=n; i++)
1685         {
1686             if(vis[i]||u==i)  continue;
1687             if(_min[i]>d[u][i]) _min[i]=d[u][i];
1688             if(_min[i]<cur) cur=_min[i], v=i;
1689         }
1690         u=v, ans+=cur, cur=_min[0];
1691     }
1692 
1693     printf("%d\n", ans);
1694     return ;
1695 }
1696 
1697 int main()
1698 {
1699     while(scanf("%d", &n)!=EOF) Read(), Work();
1700     return 0;
1701 }