锘??xml version="1.0" encoding="utf-8" standalone="yes"?>欧美日韩精品久久,久久免费高清,亚洲国产天堂网精品网站 http://m.shnenglu.com/CSniper/zh-cn Mon, 29 Sep 2025 23:16:39 GMT Mon, 29 Sep 2025 23:16:39 GMT 60 [DP] PKU 1141 鎷彿搴忓垪 http://m.shnenglu.com/CSniper/archive/2012/10/11/193163.htmlyajunw yajunw Thu, 11 Oct 2012 05:57:00 GMT http://m.shnenglu.com/CSniper/archive/2012/10/11/193163.html http://m.shnenglu.com/CSniper/comments/193163.html http://m.shnenglu.com/CSniper/archive/2012/10/11/193163.html#Feedback 0 http://m.shnenglu.com/CSniper/comments/commentRss/193163.html http://m.shnenglu.com/CSniper/services/trackbacks/193163.html DP, 璁板綍璺緞銆?br />#聽include聽 < stdio.h > #聽include聽< string .h > #聽define聽N聽205 #聽define聽INF聽1000000000 #聽define聽Mid聽(1 聽 << 聽 10 ) #聽define聽Lft聽( 1 聽 << 聽 9 聽) #聽define聽Rgt聽( 1 聽 << 聽 8 聽) char 聽buf[N]; int 聽f[N][N],聽p[N][N]; int 聽dp( int 聽x,聽 int 聽y) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 int 聽 & 聽ans聽 = 聽f[x][y]; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 if 聽(ans聽 != 聽 - 1 )聽 return 聽ans; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 if 聽(x聽 > 聽y)聽 return 聽ans聽 = 聽 0 ; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽ans聽 = 聽INF; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 if 聽(聽(buf[x] == ' ( ' && buf[y] == ' ) ' )聽 || 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽(buf[x]== ' [ ' && buf[y] == ' ] ' )聽) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 if 聽(ans聽 > 聽dp(x + 1 ,聽y - 1 )) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽p[x][y]聽 = 聽Mid; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽ans聽 = 聽f[x + 1 ][y - 1 ]; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 if 聽(聽buf[x] == ' ( ' 聽 || 聽buf[x] == ' [ ' 聽) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 if 聽(ans聽 > 聽dp(x + 1 ,聽y) + 1 ) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽p[x][y]聽 = 聽Rgt; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽ans聽 = 聽f[x + 1 ][y]聽 + 聽 1 ; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 if 聽(聽buf[y] == ' ) ' 聽 || 聽buf[y] == ' ] ' 聽) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 if 聽(ans聽 > 聽dp(x,聽y - 1 ) + 1 ) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽p[x][y]聽 = 聽Lft; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽ans聽 = 聽f[x][y - 1 ]聽 + 聽 1 ; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 for 聽( int 聽i聽 = 聽x;聽i聽 < 聽y;聽 ++ i) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 if 聽(ans聽 > 聽dp(x,聽i) + dp(i + 1 ,聽y)) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽p[x][y]聽 = 聽i; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽ans聽 = 聽f[x][i]聽 + 聽f[i + 1 ][y]; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return 聽ans; } void 聽print( int 聽s,聽 int 聽t) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 switch (p[s][t]) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 case 聽Mid: 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽putchar(buf[s]),聽print(s + 1 ,聽t - 1 ),聽putchar(buf[t]); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 break ; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 case 聽Lft: 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 if 聽(buf[t]聽 == 聽 ' ) ' ) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽putchar( ' ( ' ),聽print(s,聽t - 1 ),聽putchar( ' ) ' ); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 else 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽putchar(' [ ' ),聽print(s,聽t - 1 ),聽putchar( ' ] ' ); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 break ; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 case 聽Rgt: 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 if 聽(buf[s]聽 == 聽 ' ( ' ) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽putchar( ' ( ' ),聽print(s + 1 ,聽t),聽putchar( ' ) ' ); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 else 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽putchar(' [ ' ),聽print(s + 1 ,聽t),聽putchar( ' ] ' ); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 break ; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 case 聽 0 : 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 for 聽( int 聽i聽 = 聽s;聽i聽 <= 聽t;聽 ++ i) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽putchar(buf[i]); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 break ; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 default : 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽print(s,聽p[s][t]),聽print(p[s][t] + 1 ,聽t); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 break ; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} } int 聽main() { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 int 聽n; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽buf[ 0 ]聽 = 聽 0 ,聽scanf( " %s " ,聽buf + 1 ); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽memset(f,聽 - 1 ,聽 sizeof (f)); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽memset(p,聽 0 ,聽 sizeof (p)); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽n聽 = 聽strlen(buf + 1 ); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽dp( 1 ,聽n),聽print( 1 ,聽n),聽putchar( ' \n ' ); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return 聽 0 ; }
]]> [DP] PKU 1181 媯嬬洏鍒嗗壊 http://m.shnenglu.com/CSniper/archive/2012/10/11/193160.htmlyajunw yajunw Thu, 11 Oct 2012 04:14:00 GMT http://m.shnenglu.com/CSniper/archive/2012/10/11/193160.html http://m.shnenglu.com/CSniper/comments/193160.html http://m.shnenglu.com/CSniper/archive/2012/10/11/193160.html#Feedback 0 http://m.shnenglu.com/CSniper/comments/commentRss/193160.html http://m.shnenglu.com/CSniper/services/trackbacks/193160.html dp#聽include聽 < stdio.h > #聽include聽< string .h > #聽include聽< math.h > #聽define聽M聽(8 聽 + 聽 3 ) #聽define聽N聽( 14 聽 + 聽 3 ) #聽define聽INF聽 1000000000 int 聽n,聽m聽 = 聽 8 ; int 聽a[M][M]; int 聽s[M][M]; int 聽f[N][M][M][M][M]; int 聽Min( int 聽x,聽 int 聽y)聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return 聽x < y聽 ? 聽x:y; } int 聽cal( int 聽x1,聽 int 聽y1,聽 int 聽x2,聽 int 聽y2) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 int 聽ret聽 = 聽s[x2][y2] + s[x1 - 1 ][y1 - 1 ] - s[x1 - 1 ][y2] - s[x2][y1 - 1 ]; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return 聽ret聽 * 聽ret; } void 聽pre( void ) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 int 聽i,聽j,聽t; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 for 聽(i聽 = 聽 1 ;聽i聽 <= 聽m;聽 ++ i) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 for 聽(j聽 = 聽 1 ;聽j聽 <= 聽m;聽 ++ j) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽scanf( " %d " ,聽 & a[i][j]); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 for 聽(i聽 = 聽 0 ;聽i聽 < 聽N;聽 ++ i) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽s[i][ 0 ]聽 = 聽s[ 0 ][i]聽 = 聽 0 ; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 for 聽(i聽 = 聽 1 ;聽i聽 <= 聽m;聽 ++ i) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽t聽 = 聽 0 ; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 for 聽(j聽 = 聽 1 ;聽j聽 <= 聽m;聽 ++ j) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽t聽 += 聽a[i][j]; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽s[i][j]聽 = 聽t聽 + 聽s[i - 1 ][j]; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽memset(f,聽 - 1 ,聽 sizeof (f)); } int 聽dp( int 聽k,聽 int 聽x1,聽 int 聽y1,聽 int 聽x2,聽 int 聽y2) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 int 聽i,聽j; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 int 聽 & 聽ans聽 = 聽f[k][x1][y1][x2][y2]; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 if 聽(ans聽 != 聽 - 1 ) return 聽ans; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 if 聽(k聽 == 聽 1 )聽 return 聽ans聽 = 聽cal(x1,聽y1,聽x2,聽y2); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽ans聽 = 聽INF; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 for 聽(i聽 = 聽x1;聽i聽 < 聽x2;聽 ++ i) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽ans聽 = 聽Min(聽ans,聽Min(聽dp(k - 1 ,聽x1,聽y1,聽i,聽y2) + cal(i + 1 ,聽y1,聽x2,聽y2), 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽dp(k - 1 ,聽i + 1 ,聽y1,聽x2,聽y2) + cal(x1,聽y1,聽i,聽y2)聽)聽); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 for 聽(j聽 = 聽y1;聽j聽 < 聽y2;聽 ++ j) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽ans聽 = 聽Min(聽ans,聽Min(聽dp(k - 1 ,聽x1,聽y1,聽x2,聽j) + cal(x1,聽j + 1 ,聽x2,聽y2), 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽dp(k - 1 ,聽x1,聽j + 1 ,聽x2,聽y2) + cal(x1,聽y1,聽x2,聽j)聽)聽); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return 聽ans; } void 聽solve( void ) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 double 聽ans; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽ans聽 = 聽(聽 1.0 * dp(n,聽 1 ,聽 1 ,聽 8 ,聽 8 )聽) / (聽 1.0 * n聽) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 - 聽( 1.0 * s[ 8 ][ 8 ] / n) * ( 1.0 * s[ 8 ][ 8 ] / n); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽printf( " %.3f\n " ,聽sqrt(ans)聽); } int 聽main() { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽scanf( " %d " ,聽 & n); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽pre(); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽solve(); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return 聽 0 ; }
]]> problem 1008 Chengdu http://m.shnenglu.com/CSniper/archive/2012/09/16/190889.htmlyajunw yajunw Sun, 16 Sep 2012 09:06:00 GMT http://m.shnenglu.com/CSniper/archive/2012/09/16/190889.html http://m.shnenglu.com/CSniper/comments/190889.html http://m.shnenglu.com/CSniper/archive/2012/09/16/190889.html#Feedback 0 http://m.shnenglu.com/CSniper/comments/commentRss/190889.html http://m.shnenglu.com/CSniper/services/trackbacks/190889.html #聽include聽 < cstdio > #聽include聽< algorithm > #聽define聽N聽100005 typedef聽__int64聽LL;int 聽n; int 聽a[N],聽b[N],聽r[N]; bool 聽cmp( int 聽x,聽 int 聽y) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return 聽a[x] - b[y]聽 == 聽a[y] - b[x]聽 ? 聽a[x] > a[y]聽:聽a[x] - b[y] > a[y] - b[x]; } int 聽main() { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽freopen( " in.txt " ,聽 " r " ,聽stdin); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 int 聽i; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽LL聽w,聽ans; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 while 聽( ~ scanf( " %d " ,聽 & n)) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 for 聽(i聽 = 聽 0 ;聽i聽 < 聽n;聽 ++ i) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽scanf( " %d%d " ,聽 & a[i],聽 & b[i]),聽r[i]聽 = 聽i; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽std::sort(r,聽r + n,聽cmp); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽w聽 = 聽a[聽r[n - 1 ]聽]; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽ans聽 = 聽 0 ; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 for 聽(i聽 = 聽n - 2 ;聽i聽 >= 聽 0 ;聽 -- i) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 if 聽(ans聽 < 聽w - (LL)b[聽r[i]聽])聽ans聽 = 聽w聽 - 聽(LL)b[聽r[i]聽]; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽w聽 += 聽(LL)a[聽r[i]聽]; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽printf( " %I64d\n " ,聽ans); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return 聽 0 ; }
]]>2011 South Pacific Regional Contest E -- RealPhobia http://m.shnenglu.com/CSniper/archive/2012/09/15/190783.htmlyajunw yajunw Sat, 15 Sep 2012 09:26:00 GMT http://m.shnenglu.com/CSniper/archive/2012/09/15/190783.html http://m.shnenglu.com/CSniper/comments/190783.html http://m.shnenglu.com/CSniper/archive/2012/09/15/190783.html#Feedback 0 http://m.shnenglu.com/CSniper/comments/commentRss/190783.html http://m.shnenglu.com/CSniper/services/trackbacks/190783.html
# include <stdio.h> typedef long long int LL; /***************************************/ LL Min(LL x, LL y) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return x < y ? x : y; } LL Max(LL x, LL y) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return x > y ? x : y; } LL gcd(LL x, LL y) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 if (!y) return x; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return gcd(y, x%y); } LL ex_gcd(LL a,LL b,LL &x,LL &y) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 if(b==0) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 x=1; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 y=0; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return a; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 } 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 LL g,t; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 g=ex_gcd(b,a%b,x,y); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 t=x; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 x=y; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 y=t-a/b*y; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return g; } LL niyuan(LL b,LL p) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 LL x,y; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 ex_gcd(b,p,x,y); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return x=(x%p+p)%p; } /***************************************/ struct frac { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 LL n, d; } ; LL A, B, C, D; LL LLabs(LL x) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return x>0 ? x:-x; } void slim(frac &x) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 LL tmp = LLabs(gcd(x.d, x.n)); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 x.d /= tmp; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 x.n /= tmp; } frac dif(frac x, frac y) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 frac z; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 z.d = x.d * y.d; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 z.n = LLabs(x.n*y.d-x.d*y.n); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 slim(z); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return z; } int cmp(frac x, frac y) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return x.n*y.d - x.d*y.n>0 ? 1:0; } frac cal(frac x, frac y, frac BA) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return cmp(dif(x, BA), dif(y, BA)) ? y:x; } void solve(void) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 frac BA; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 BA.n = A, BA.d = B; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 LL n1 = niyuan(B, A); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 if (n1 == 0) n1 = A; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 LL d1 = (B*n1-1) / A; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 LL d2 = niyuan(A, B); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 if (d2 == 0) d2 = B; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 LL n2 = (A*d2-1) / B; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 frac a, b; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 a.n = n1, a.d = d1; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 b.n = n2, b.d = d2; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 slim(a), slim(b); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 frac ans = cal(a, b, BA); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 printf("%lld/%lld\n", ans.n, ans.d); } /***************************************/ int main() { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 freopen("in.txt", "r", stdin); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 int T; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 scanf("%d", &T); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 while (T--) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 scanf("%lld/%lld", &A, &B); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 LL tmp = gcd(A, B); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 if (tmp != 1) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 printf("%lld/%lld\n", A/tmp, B/tmp); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 } 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 else solve(); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 } 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return 0; }
Bert is a programmer with a real fear of floating point arithmetic. Bert has quite
successfully used rational numbers to write his programs but he does not like it when the
denominator grows large.
Your task is to help Bert by writing a program that decreases the denominator of a
rational number, whilst introducing the smallest error possible. For a rational number A /B ,
where B > 2 and 0 < A < B , your program needs to identify a rational number C /D such
that:
0 < C < D < B , and
the error
| A /B - C /D | is the minimum over all possible values of C and D , and
D
is the smallest such positive integer.
Output
For each case, the output consists of a fraction on a line by itself. The fraction should
be formatted as two integers separated by `/ '.
Sample Output
1/3
1/2
8/13
]]>HDOJ 3641 Treasure Hunting http://m.shnenglu.com/CSniper/archive/2012/09/08/189946.htmlyajunw yajunw Sat, 08 Sep 2012 08:01:00 GMT http://m.shnenglu.com/CSniper/archive/2012/09/08/189946.html http://m.shnenglu.com/CSniper/comments/189946.html http://m.shnenglu.com/CSniper/archive/2012/09/08/189946.html#Feedback 0 http://m.shnenglu.com/CSniper/comments/commentRss/189946.html http://m.shnenglu.com/CSniper/services/trackbacks/189946.html Output
For each test case output the result x in one line. Source 2010 Asia Regional Hangzhou Site Online Contest
#聽include聽 < stdio.h > #聽include聽< string .h > #聽include聽< math.h > #聽define聽N聽101 typedef聽long 聽 long 聽 int 聽LL; int 聽n; /* ***************************************************** */ int 聽p[ 50 ],聽top聽 = 聽 0 ; int 聽isPrime( int 聽x) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 int 聽i; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 if 聽(x % 2 == 0 )聽 return 聽x == 2 ; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 if 聽(x % 3 == 0 )聽 return 聽x == 3 ; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 if 聽(x % 5 == 0 )聽 return 聽x == 5 ; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 for 聽(i聽 = 聽 7 ;聽i聽 < 聽x;聽i聽 += 聽 5 ) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 if 聽(x % i聽 == 聽 0 )聽 return 聽 0 ; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return 聽 1 ; } void 聽pre( void ) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 int 聽i; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 for 聽(i聽 = 聽 2 ;聽i聽 < 聽N;聽 ++ i) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 if 聽(isPrime(i))聽p[top ++ ]聽 = 聽i; } /* ***************************************************** */ LL聽pn[50 ]; void 聽init( void ) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 int 聽i,聽j,聽x; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽LL聽cnt; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽LL聽num; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽memset(pn,聽 0 ,聽 sizeof (pn)); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽scanf( " %d " ,聽 & n); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 for 聽(i聽 = 聽 0 ;聽i聽 < 聽n;聽 ++ i) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽scanf( " %d%I64d " ,聽 & x,聽 & num); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 for 聽(j聽 = 聽 0 ;聽j聽 < 聽top;聽 ++ j) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 if 聽(x % p[j]聽 == 聽 0 ) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽cnt聽 = 聽 0 ; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 while 聽(x % p[j] == 0 )聽 ++ cnt,聽x /= p[j]; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽pn[j]聽 += 聽cnt * num; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} } LL聽Max(LL聽x,聽LL聽y) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return 聽x > y聽 ? 聽x:y; } LL聽mypow( int 聽pr,聽 int 聽cnt) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽LL聽ret聽 = 聽 1 ; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 while 聽(cnt聽 > 聽 0 )聽 -- cnt,聽ret聽 *= 聽pr; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return 聽ret; } LL聽cal( int 聽pr,聽LL聽tot) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 int 聽tmp; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽LL聽ppow聽 = 聽 0 ,聽temp; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 while 聽(tot聽 > 聽 0 ) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽tmp聽 = 聽( int )floor(log(tot * (pr - 1 ) + 1 ) / log(pr)) + 1 ; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 while 聽((mypow(pr,聽tmp) - 1 ) / (pr - 1 )聽 > 聽tot)聽 -- tmp; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽temp聽 = 聽mypow(pr,聽tmp); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽ppow聽 += 聽temp; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽tot聽 -= 聽(temp - 1 ) / (pr - 1 ); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return 聽ppow; } void 聽solve( void ) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 int 聽i; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽LL聽ans聽 = 聽 0 ; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 for 聽(i聽 = 聽 0 ;聽i聽 < 聽top;聽 ++ i)聽 if 聽(pn[i]聽 != 聽 0 ) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽ans聽 = 聽Max(ans,聽cal(p[i],聽pn[i])); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽printf( " %I64d\n " ,聽ans); } int 聽main() { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 int 聽T; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽pre(); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽scanf( " %d " ,聽 & T); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 while 聽(T -- )聽init(),聽solve(); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return 聽 0 ; }
]]>[鏍戠姸鏁扮粍] PKU 2299 Ultra-QuickSort http://m.shnenglu.com/CSniper/archive/2012/09/02/189160.htmlyajunw yajunw Sun, 02 Sep 2012 09:53:00 GMT http://m.shnenglu.com/CSniper/archive/2012/09/02/189160.html http://m.shnenglu.com/CSniper/comments/189160.html http://m.shnenglu.com/CSniper/archive/2012/09/02/189160.html#Feedback 0 http://m.shnenglu.com/CSniper/comments/commentRss/189160.html http://m.shnenglu.com/CSniper/services/trackbacks/189160.html #聽include聽 < stdio.h > #聽include聽< string .h > #聽include聽< algorithm > using 聽 namespace 聽std; #聽define聽N聽 500005 typedef聽long 聽 long 聽 int 聽LL; int 聽n; LL聽a[N]; int 聽r[N],聽s[N],聽c[N]; /* ************************************************* */ int 聽getsum( int 聽x) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 int 聽ret聽 = 聽 0 ; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 while 聽(x聽 > 聽 0 )聽ret聽 += 聽c[x],聽x聽聽 -= 聽x & ( - x); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return 聽ret; } void 聽inc( int 聽x) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 while 聽(x聽 <= 聽n)聽 ++ 聽c[x],聽x聽 += 聽x & ( - x); } /* ************************************************* */ bool 聽cmp( int 聽x,聽 int 聽y) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return 聽a[x]聽 > 聽a[y]; } int 聽main() { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽LL聽ans; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 int 聽i; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 while 聽(scanf( " %d " ,聽 & n),聽n) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽memset(c + 1 ,聽 0 ,聽 sizeof (c[ 0 ]) * n); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 for 聽(i聽 = 聽 0 ;聽i聽 < 聽n;聽 ++ i) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽r[i]聽 = 聽i,聽scanf( " %lld " ,聽 & a[i]); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽sort(r,聽r + n,聽cmp); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 for 聽(i聽 = 聽 0 ;聽i聽 < 聽n;聽 ++ i)聽s[r[i]]聽 = 聽i; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽ans聽 = 聽 0 ; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 for 聽(i聽 = 聽 0 ;聽i聽 < 聽n;聽 ++ i) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽ans聽 += 聽getsum(s[i] + 1 ),聽inc(s[i] + 1 ); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽printf( " %lld\n " ,聽ans); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return 聽 0 ; }
]]>[鏍戠姸鏁扮粍] PKU 2155 Matrix http://m.shnenglu.com/CSniper/archive/2012/09/02/189157.htmlyajunw yajunw Sun, 02 Sep 2012 09:29:00 GMT http://m.shnenglu.com/CSniper/archive/2012/09/02/189157.html http://m.shnenglu.com/CSniper/comments/189157.html http://m.shnenglu.com/CSniper/archive/2012/09/02/189157.html#Feedback 0 http://m.shnenglu.com/CSniper/comments/commentRss/189157.html http://m.shnenglu.com/CSniper/services/trackbacks/189157.html #聽include聽 < stdio.h > #聽include聽< string .h > #聽define聽N聽1005 int 聽n,聽c[N][N]; void 聽clr( int 聽nn) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 int 聽i; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 for 聽(i聽 = 聽 1 ;聽i聽 <= 聽nn;聽 ++ i) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽memset(c[i] + 1 ,聽 0 ,聽 sizeof (c[ 0 ][ 0 ]) * nn); } /* **************************************************************** */ void 聽inc( int 聽x,聽 int 聽y) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 int 聽t; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 while 聽(x聽 <= 聽n) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽t聽 = 聽y; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 while 聽(t聽 <= 聽n)聽 ++ 聽c[x][t],聽t聽 += 聽t & ( - t); // 聽printf("%d\n",聽t); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽x聽 += 聽x & ( - x); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} } int 聽getsum( int 聽x,聽 int 聽y) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 int 聽t,聽ret聽 = 聽 0 ; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 while 聽(x聽 > 聽 0 ) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽t聽 = 聽y; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 while 聽(t聽 > 聽 0 )聽ret聽 += 聽c[x][t],聽t聽 -= 聽t & ( - t); // 聽printf("%d\n",聽t); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽x聽 -= 聽x & ( - x); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return 聽ret; } /* **************************************************************** */ int 聽main() { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 char 聽ins[ 3 ]; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 int 聽X,聽T,聽x0,聽y0,聽x1,聽y1; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽scanf( " %d " ,聽 & X); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 while 聽(X -- ) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽scanf( " %d%d " ,聽 & n,聽 & T),聽clr(n); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 while 聽(T -- ) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽scanf( " %s%d%d " ,聽ins,聽 & x0,聽 & y0); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 switch (ins[ 0 ]) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 case 聽 ' C ' : 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽scanf( " %d%d " ,聽 & x1,聽 & y1); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽inc(x0,聽y0); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽inc(x0,聽y1 + 1 ); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽inc(x1 + 1 ,聽y0); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽inc(x1 + 1 ,聽y1 + 1 ); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 break ; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 case 聽 ' Q ' :聽puts((getsum(x0,聽y0) & 0x1 )聽 ? 聽 " 1 " : " 0 " );聽 break ; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 if 聽(X)聽putchar( ' \n ' ); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return 聽 0 ; }
]]>[鏍戠姸鏁扮粍] PKU 3067 Japan http://m.shnenglu.com/CSniper/archive/2012/09/02/189134.htmlyajunw yajunw Sun, 02 Sep 2012 05:53:00 GMT http://m.shnenglu.com/CSniper/archive/2012/09/02/189134.html http://m.shnenglu.com/CSniper/comments/189134.html http://m.shnenglu.com/CSniper/archive/2012/09/02/189134.html#Feedback 0 http://m.shnenglu.com/CSniper/comments/commentRss/189134.html http://m.shnenglu.com/CSniper/services/trackbacks/189134.html #聽include聽 < stdio.h > #聽include聽< string .h > #聽include聽< algorithm > using 聽 namespace 聽std; #聽define聽B聽 1005 #聽define聽N聽1000005 int 聽n,聽m,聽k,聽a[B]; int 聽r[N],聽x[N],聽y[N]; bool 聽cmp( int 聽i,聽 int 聽j) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return 聽x[i] ^ x[j]聽 ? 聽x[i] > x[j]聽:聽y[i] > y[j]; } /* ****************************************************** */ int 聽getsum( int 聽x) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 int 聽ret聽 = 聽 0 ; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 while 聽(x聽 > 聽 0 )聽ret聽 += 聽a[x],聽x聽 -= 聽x & ( - x); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return 聽ret; } void 聽inc( int 聽x) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 while 聽(x聽 <= 聽m)聽 ++ 聽a[x],聽x聽 += 聽x & ( - x); } /* ****************************************************** */ int 聽main() { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 int 聽ii,聽T,聽i,聽xx; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 long 聽 long 聽 int 聽ans; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽scanf( " %d " ,聽 & T); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 for 聽(ii聽 = 聽 1 ;聽ii聽 <= 聽T;聽 ++ ii) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽scanf( " %d%d%d " ,聽 & n,聽 & m,聽 & k); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽memset(a + 1 ,聽 0 ,聽 sizeof (a[ 0 ]) * m); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 for 聽(i聽 = 聽 0 ;聽i聽 < 聽k;聽 ++ i) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽r[i]聽 = 聽i,聽scanf( " %d%d " ,聽 & x[i],聽 & y[i]); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽sort(r,聽r + k,聽cmp); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽ans聽 = 聽 0 ; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 for 聽(i聽 = 聽 0 ;聽i聽 < 聽k;聽 ++ i) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽ans聽 += 聽getsum(y[r[i]] - 1 ),聽inc(y[r[i]]); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽printf( " Test聽case聽%d:聽%lld\n " ,聽ii,聽ans); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return 聽 0 ; }
]]>[鏍戠姸鏁扮粍] PKU 2481 Cows http://m.shnenglu.com/CSniper/archive/2012/09/02/189120.htmlyajunw yajunw Sun, 02 Sep 2012 03:51:00 GMT http://m.shnenglu.com/CSniper/archive/2012/09/02/189120.html http://m.shnenglu.com/CSniper/comments/189120.html http://m.shnenglu.com/CSniper/archive/2012/09/02/189120.html#Feedback 0 http://m.shnenglu.com/CSniper/comments/commentRss/189120.html http://m.shnenglu.com/CSniper/services/trackbacks/189120.html
聽1 聽#聽include聽 < cstdio > 聽2 聽#聽include聽 < cstring > 聽3 聽#聽include聽 < algorithm > 聽4 聽using 聽 namespace 聽std; 聽5 聽聽6 聽#聽define聽B聽 100005 聽7 聽#聽define聽N聽 100005 聽8 聽聽9 聽struct 聽Intv聽{ int 聽s,聽e;}; 10 聽11 聽Intv聽c[N]; 12 聽int 聽n,聽a[B],聽r[N],聽le[N]; 13 聽14 聽bool 聽cmp( const 聽 int 聽x,聽 const 聽 int 聽y) 15 聽{ 16 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 if 聽(c[x].s聽 == 聽c[y].s)聽 return 聽c[x].e聽 > 聽c[y].e; 17 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return 聽c[x].s聽 < 聽c[y].s; 18 聽} 19 聽/* ************************************************ */ 20 聽int 聽getsum( int 聽x) 21 聽{ 22 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 int 聽ret聽 = 聽 0 ; 23 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 while 聽(x聽 > 聽 0 )聽ret聽 += 聽a[x],聽x聽 -= 聽x & ( - x); 24 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return 聽ret; 25 聽} 26 聽void 聽inc( int 聽x) 27 聽{ 28 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 while 聽(x聽 <= 聽B)聽 ++ a[x],聽x聽 += 聽x & ( - x); 29 聽} 30 聽/* ************************************************ */ 31 聽int 聽main() 32 聽{ 33 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 int 聽i,聽n,聽x; 34 聽35 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 while 聽(scanf( " %d " ,聽 & n),聽n) 36 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 37 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽memset(a,聽 0 ,聽 sizeof (a)); 38 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 for 聽(i聽 = 聽 0 ;聽i聽 < 聽n;聽 ++ i) 39 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽r[i]聽 = 聽i,聽scanf( " %d%d " ,聽 & c[i].s,聽 & c[i].e); 40 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽sort(r,聽r + n,聽cmp); 41 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 for 聽(i聽 = 聽 0 ;聽i聽 < 聽n;聽 ++ i) 42 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 43 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽x聽 = 聽c[r[i]].e聽 + 聽 1 ,聽inc(x); 44 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 if 聽(i聽 && 聽c[r[i]].e == c[r[i - 1 ]].e聽 && 聽c[r[i]].s == c[r[i - 1 ]].s) 45 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽le[r[i]]聽 = 聽le[r[i - 1 ]]; 46 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 else 47 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽le[r[i]]聽 = 聽i - getsum(x - 1 ); 48 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 49 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 for 聽(i聽 = 聽 0 ;聽i聽 < 聽n;聽 ++ i) 50 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 51 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 if 聽(i)聽putchar( ' 聽 ' ); 52 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽printf( " %d " ,聽le[i]); 53 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 54 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽putchar( ' \n ' ); 55 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 56 聽57 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽 return 聽 0 ; 58 聽} 59 聽
]]> [鏍戠姸鏁扮粍] PKU 3252 Star http://m.shnenglu.com/CSniper/archive/2012/09/02/189099.htmlyajunw yajunw Sun, 02 Sep 2012 02:21:00 GMT http://m.shnenglu.com/CSniper/archive/2012/09/02/189099.html http://m.shnenglu.com/CSniper/comments/189099.html http://m.shnenglu.com/CSniper/archive/2012/09/02/189099.html#Feedback 0 http://m.shnenglu.com/CSniper/comments/commentRss/189099.html http://m.shnenglu.com/CSniper/services/trackbacks/189099.html
#聽include聽
<
stdio.h
>
int
聽a[
32005
],聽le[
15005
],聽n;
/*
*********************************************************
*/
int
聽getsum(
int
聽x) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽
int
聽ret聽
=
聽
0
; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽
while
聽(x聽
>
聽
0
)聽ret聽
+=
聽a[x],聽x聽
-=
聽(x
&
(
-
x)); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽
return
聽ret; }
void
聽inc(
int
聽x) { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽
while
聽(x聽
<=
聽
32005
)聽
++
聽a[x],聽x聽
+=
聽(x
&
(
-
x)); }
/*
*********************************************************
*/
int
聽main() { 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽
int
聽i,聽x,聽y; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽scanf(
"
%d
"
,聽
&
n); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽
for
聽(i聽
=
聽
0
;聽i聽
<
聽n;聽
++
i) 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽{ 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽scanf(
"
%d%d
"
,聽
&
x,聽
&
y),聽
++
x; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽
++
聽le[getsum(x)]; 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽inc(x); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽} 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽
for
聽(i聽
=
聽
0
;聽i聽
<
聽n;聽
++
i)聽printf(
"
%d\n
"
,聽le[i]); 聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽聽
return
聽
0
; }
]]> 青青草原综合久久大伊人导航_色综合久久天天综合_日日噜噜夜夜狠狠久久丁香五月_热久久这里只有精品
国产精品久久久久久久久久免费 |
亚洲中无吗在线 |
一区二区日韩精品 |
亚洲另类在线视频 |
一区二区三区www |
亚洲欧美日韩高清 |
久久精品国产清高在天天线 |
久久精品亚洲乱码伦伦中文 |
美女精品在线观看 |
欧美激情视频在线播放 |
亚洲福利国产 |
一区二区三区四区精品 |
性亚洲最疯狂xxxx高清 |
毛片一区二区三区 |
欧美日韩在线看 |
国产一区久久 |
亚洲免费观看视频 |
欧美一区二区在线看 |
久久综合成人精品亚洲另类欧美 |
亚洲国产精品成人 |
亚洲欧美日韩一区二区在线 |
美女网站久久 |
国产日韩一区二区三区在线播放 |
亚洲国产日韩美 |
午夜性色一区二区三区免费视频 |
欧美.www |
欧美一级免费视频 |
欧美激情1区2区3区 |
狠狠色狠狠色综合日日91app |
亚洲欧洲精品一区二区三区不卡
|
国产女人18毛片水18精品 |
国产一区二区三区日韩 |
日韩午夜av |
鲁大师影院一区二区三区 |
日韩亚洲国产精品 |
久久久噜久噜久久综合 |
欧美亚韩一区 |
亚洲美女精品久久 |
久久久久综合 |
亚洲直播在线一区 |
欧美日韩大片 |
亚洲日本激情 |
女女同性精品视频 |
欧美一级日韩一级 |
国产精品福利av |
一区二区三区 在线观看视 |
女人香蕉久久**毛片精品 |
午夜精品福利视频 |
国产精品99免视看9 |
夜夜嗨av一区二区三区 |
欧美激情亚洲自拍 |
老色鬼久久亚洲一区二区 |
国产一区二区三区在线观看视频 |
性xx色xx综合久久久xx |
一区二区三区产品免费精品久久75 |
欧美国产日韩一区二区三区 |
1000部精品久久久久久久久 |
久久国产精品久久久久久久久久 |
亚洲一区区二区 |
国产精品久久久久久久久搜平片 |
亚洲视频电影在线 |
日韩一区二区精品 |
欧美日韩在线高清 |
亚洲五月婷婷 |
在线亚洲欧美专区二区 |
欧美视频导航 |
亚洲欧美综合网 |
午夜精彩国产免费不卡不顿大片 |
国产日韩成人精品 |
欧美中文字幕 |
久久精品综合 |
亚洲经典在线 |
亚洲美女视频网 |
国产精品乱子久久久久 |
欧美一区二区精品 |
欧美综合激情网 |
亚洲第一福利视频 |
亚洲国产精品国自产拍av秋霞 |
欧美成人综合 |
亚洲摸下面视频 |
午夜精品区一区二区三 |
国外成人在线视频 |
欧美国产欧美亚洲国产日韩mv天天看完整
|
一区二区不卡在线视频 午夜欧美不卡' |
欧美激情久久久久 |
欧美高清在线播放 |
亚洲女性裸体视频 |
久久精品视频免费观看 |
亚洲美女黄网 |
亚洲欧美一区在线 |
亚洲国产乱码最新视频 |
一本久道综合久久精品 |
国产在线精品成人一区二区三区 |
亚洲第一在线 |
国产精品资源 |
亚洲黄色成人网 |
国产欧美日韩免费 |
欧美大学生性色视频 |
国产精品第一页第二页第三页 |
久久久青草婷婷精品综合日韩 |
欧美大尺度在线观看 |
亚洲欧美一区二区原创 |
麻豆freexxxx性91精品 |
欧美亚洲日本网站 |
欧美国产一区视频在线观看
|
亚洲精品乱码久久久久久蜜桃91
|
欧美日本国产一区 |
久久国产精品黑丝 |
免费日韩成人 |
久久久久久久综合狠狠综合 |
欧美黄在线观看 |
久久漫画官网 |
国产精品日韩一区 |
亚洲人成毛片在线播放 |
韩日在线一区 |
亚洲欧美激情视频在线观看一区二区三区 |
在线日韩日本国产亚洲 |
亚洲伊人色欲综合网 |
亚洲美女视频在线免费观看 |
久久久久久久一区二区 |
午夜视频精品 |
欧美天堂亚洲电影院在线观看
|
欧美伊人久久久久久午夜久久久久 |
日韩一级在线观看 |
久久人91精品久久久久久不卡 |
性欧美精品高清 |
欧美午夜精品理论片a级大开眼界
欧美午夜精品理论片a级按摩
|
久久久不卡网国产精品一区 |
国产精品看片资源 |
av不卡免费看 |
亚洲在线国产日韩欧美 |
欧美日韩国产精品自在自线 |
亚洲经典视频在线观看 |
欧美在线视频观看 |
亚洲人成在线影院 |
伊人一区二区三区久久精品 |
亚洲欧美激情四射在线日
|
午夜精品www |
欧美一二三区精品 |
国产精品影音先锋 |
午夜欧美精品 |
久久综合福利 |
亚洲国产色一区 |
欧美国产日韩视频 |
亚洲丶国产丶欧美一区二区三区 |
91久久夜色精品国产九色 |
女同一区二区 |
亚洲精品一区二区在线 |
亚洲小说区图片区 |
国产精品久久亚洲7777 |
午夜精品久久久久久久蜜桃app |
欧美一区二区三区日韩视频 |
国产一区二区你懂的 |
久久久九九九九 |
91久久精品国产 |
午夜精品国产 |
影音先锋亚洲视频 |
免费成人在线视频网站 |
亚洲人成人一区二区在线观看 |
亚洲一级黄色片 |
国产一区二区三区四区在线观看 |
久久亚洲私人国产精品va |
亚洲国产成人精品视频 |
亚洲一区二区三 |
激情婷婷欧美 |
欧美久久久久久久久 |
亚洲专区一二三 |
免费91麻豆精品国产自产在线观看 |
亚洲高清视频的网址 |
欧美日韩国产精品
|
欧美三级网页 |
久久精品国产99国产精品澳门
|
久久九九国产 |
亚洲免费av电影 |
国产日韩一区在线 |
欧美福利一区 |
欧美在线观看网址综合 |
亚洲国产日韩综合一区 |
欧美中文字幕在线观看 |
91久久夜色精品国产九色 |
国产老女人精品毛片久久 |
欧美h视频在线 |
欧美一区二区在线视频 |
亚洲精品久久久久中文字幕欢迎你 |
先锋影音国产精品 |
亚洲人成小说网站色在线 |
国产欧美日韩在线播放 |
欧美日韩mv |
免费成人黄色片 |
久久九九热re6这里有精品 |
一区二区三区鲁丝不卡 |
亚洲第一精品福利 |
久久中文字幕一区 |
欧美在线视频一区二区 |
亚洲一区二区三区在线播放 |
日韩一级成人av |
亚洲人体一区 |
亚洲第一在线综合在线 |
国模叶桐国产精品一区 |
国产美女扒开尿口久久久 |