锘??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
; }
]]> 青青草原综合久久大伊人导航_色综合久久天天综合_日日噜噜夜夜狠狠久久丁香五月_热久久这里只有精品
亚洲二区在线 |
亚洲国产美国国产综合一区二区 |
亚洲一区二区三区欧美 |
亚洲人成久久 |
99国产精品私拍 |
中文精品视频一区二区在线观看 |
亚洲无限av看 |
久久精品国产一区二区三区免费看 |
欧美在线综合视频 |
久久综合色8888 |
欧美激情亚洲自拍 |
国产精品视频你懂的 |
在线观看成人小视频 |
一区二区三区精品视频在线观看 |
亚洲欧美一区二区三区久久
|
国产一区香蕉久久 |
影音先锋亚洲精品 |
中国av一区 |
巨胸喷奶水www久久久免费动漫 |
亚洲黄网站在线观看 |
午夜精品美女自拍福到在线
|
久久精品伊人 |
亚洲激情一区 |
欧美在线免费观看视频 |
欧美成人精品一区 |
国产精品影音先锋 |
亚洲欧洲日产国产网站 |
欧美一区二区视频97 |
亚洲黑丝在线 |
午夜视黄欧洲亚洲 |
欧美电影免费网站 |
国产亚洲午夜高清国产拍精品 |
亚洲精品少妇 |
国产视频一区免费看 |
欧美成人免费网站 |
欧美三级中文字幕在线观看 |
国产日韩高清一区二区三区在线 |
亚洲精品视频中文字幕 |
久久精品盗摄 |
亚洲一区久久 |
欧美日韩亚洲另类 |
亚洲激情电影在线 |
久久午夜色播影院免费高清 |
在线亚洲一区 |
欧美日韩在线另类 |
亚洲国产精品久久人人爱蜜臀 |
久久国产精彩视频 |
亚洲男人的天堂在线观看 |
欧美精品一区二区三区四区 |
亚洲国产精品t66y |
欧美阿v一级看视频 |
久久精品国产第一区二区三区最新章节
|
欧美色道久久88综合亚洲精品 |
亚洲韩国青草视频 |
免费观看日韩av |
久久久不卡网国产精品一区 |
国产香蕉97碰碰久久人人 |
亚洲欧美日韩中文在线制服 |
一本大道久久精品懂色aⅴ |
欧美精品亚洲 |
艳女tv在线观看国产一区 |
日韩视频在线免费 |
国产精品久久福利 |
欧美在线观看一二区 |
欧美一区二区三区在线观看视频
|
日韩午夜激情 |
欧美激情欧美激情在线五月 |
免费av成人在线 |
亚洲狼人精品一区二区三区 |
亚洲国产天堂久久国产91 |
免播放器亚洲一区 |
一区二区国产日产 |
亚洲一级片在线看 |
国产亚洲视频在线 |
欧美成人69av |
欧美日韩国产综合在线 |
午夜精品久久久久久久99樱桃
|
一区二区三区欧美激情 |
欧美性jizz18性欧美 |
欧美一区二区视频网站 |
久久狠狠亚洲综合 |
亚洲美女av网站 |
亚洲视频一二区 |
国内外成人免费激情在线视频 |
久久综合色88 |
欧美日韩国产色综合一二三四 |
夜夜嗨一区二区 |
99国产一区 |
国产精品人人做人人爽人人添 |
久久av最新网址 |
久久久人成影片一区二区三区观看 |
在线日韩中文字幕 |
亚洲精品系列 |
国内一区二区三区 |
91久久精品一区二区别 |
国产精品久久久一本精品 |
老色批av在线精品 |
欧美午夜寂寞影院 |
欧美xxx成人 |
国产日韩久久 |
99pao成人国产永久免费视频 |
国精品一区二区 |
一区二区三区国产在线观看 |
在线观看不卡 |
欧美一级淫片aaaaaaa视频 |
亚洲国产欧美久久 |
校园春色国产精品 |
亚洲一二区在线 |
欧美成人精品影院 |
久久久久久久综合日本 |
欧美日韩免费在线观看 |
欧美成va人片在线观看 |
国产婷婷色一区二区三区在线 |
亚洲人午夜精品免费 |
亚洲大片一区二区三区 |
午夜精品久久久久久99热软件 |
一区二区三区久久精品 |
麻豆久久婷婷 |
欧美freesex8一10精品 |
国产尤物精品 |
性久久久久久久久 |
亚洲欧美日韩精品久久久久 |
欧美片第1页综合 |
亚洲黄页一区 |
亚洲人体偷拍 |
女女同性精品视频 |
欧美成熟视频 |
亚洲黄色一区二区三区 |
久久视频这里只有精品 |
另类春色校园亚洲 |
一区二区视频免费在线观看 |
欧美在线视频一区二区三区 |
欧美影院精品一区 |
国产精品日韩高清 |
亚洲小视频在线观看 |
亚洲综合色网站 |
裸体丰满少妇做受久久99精品
|
在线精品国产欧美 |
久久精品伊人 |
蜜臀久久99精品久久久久久9
|
亚洲第一在线综合在线 |
在线观看日韩欧美 |
久久久久久亚洲精品不卡4k岛国 |
欧美影院视频 |
国产午夜亚洲精品理论片色戒 |
欧美一级电影久久 |
久久最新视频 |
亚洲激情二区 |
欧美国产日韩视频 |
亚洲国产一区二区视频 |
亚洲欧洲一区二区在线播放
|
国产精品久久久久久久久久三级
|
99精品视频免费观看视频 |
亚洲少妇在线 |
国产欧美精品一区二区三区介绍 |
亚洲欧美日韩系列 |
裸体一区二区三区 |
99ri日韩精品视频 |
国产精品香蕉在线观看 |
欧美在线网站 |
亚洲三级国产 |
欧美在线亚洲一区 |
亚洲人成毛片在线播放 |
欧美色视频日本高清在线观看 |
亚洲欧美日韩一区二区在线
|
久久亚洲欧美国产精品乐播 |
欧美大片一区 |
亚洲视频在线一区 |
国模大胆一区二区三区 |
欧美激情第8页 |
性欧美精品高清 |
亚洲黄色性网站 |
久久激情五月丁香伊人 |
亚洲精品一区二区三区福利 |
国产精品一区二区你懂的 |
久久在线免费观看 |
亚洲一区二区三区精品动漫 |
欧美激情一区二区三区不卡 |
香蕉久久久久久久av网站 |
亚洲国产老妈 |
国产三级精品在线不卡 |
欧美激情中文字幕在线 |
久久国产精品一区二区 |
一区二区电影免费观看 |
欧美高清在线观看 |
久久精品国产免费观看 |
在线一区观看 |
亚洲片在线资源 |
国产有码一区二区 |
国产精品第2页 |
欧美另类综合 |
欧美成人午夜激情在线 |
久久激情网站 |
欧美亚洲网站 |
亚洲一区二区三区涩 |
9l视频自拍蝌蚪9l视频成人 |
亚洲国产免费看 |
欧美激情成人在线视频 |
久久深夜福利免费观看 |
欧美影院视频 |