hut 训练赛第二场 解题报告
题目来源 HDU 2008-10 Programming Contest
| ID | Origin | Title |
|---|---|---|
| Problem A | HDU 2520 | 我是菜鸟，我怕谁 |
| Problem B | HDU 2521 | 反素数 |
| Problem C | HDU 2522 | A simple problem |
| Problem D | HDU 2523 | SORT AGAIN |
| Problem E | HDU 2524 | 矩形A + B |
| Problem F | HDU 2525 | Clone Wars |
| Problem G | HDU 2526 | 浪漫手机 |
| Problem H | HDU 2527 | Safe Or Unsafe |
Problem A
仔细读题, 这个不是匀变速运动, 每一秒初,速度直接改变. 化简下可以得出结果为 n*n
参考代码:
View Code
#include<stdio.h> #include<stdlib.h> #include<string.h> const int mod = 1e4; const int N = 1e5; typedef long long LL; int main(){ int T, n; scanf("%d", &T); while( T-- ) { scanf("%d",&n); LL res = 1LL*n*n; printf("%lld\n", res%mod); } return 0; }
Problem B
仔细读题,题目虽然前面一句讲的是反素数,却非要求反素数. 只需求所给区间[a,b]因子个数最多的数,当有多个解时,输出最小的.
我们可以预处理, 将数 x 的倍数全部+1 , 通过这样枚举 x 就可以了
参考代码
View Code
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#define MAX(a,b) (a)>(b)?(a):(b)
const int N = 5010;
bool vis[N];
int g[N], n;
void init()
{
memset( vis ,0 , sizeof(vis));
for(int i = 1; i < N; i++)
g[i] = 1;
for(int i = 1; 2*i < N; i++ )
g[2*i]++;
for(int i = 3; i < N; i++)
{
g[i]++;
for(int j = 2; j*i < N; j++)
g[ j*i ]++;
}
int Max = 0;
for(int i = 1; i < N; i++)
{
if( Max < g[i] ) vis[i] = true;
Max = MAX( Max, g[i]);
}
}
int main()
{
init();
int T;
scanf("%d",&T);
while( T-- )
{
int a, b;
scanf("%d%d",&a,&b);
int Max = 0, res;
for(int i = a; i <= b; i++)
if( g[i] > Max )
{ Max = g[i]; res = i; }
printf("%d\n", res );
}
return 0;
}
Problem C
模拟除法运算, 并标记余数,当余数为0 或者 余数已被标记, 则分别为 整除解, 第一个循环节.
不过这题有点恶心的地方是,如果计算写到函数中,就TLE. 只能在 main函数中操作. 1K ms . 依旧百思不得其解
PS: 有兴趣的还可以了解下手动开根号. 12年湖南省赛就有这么一题
参考代码
View Code
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
#include<math.h>
const int N = 1e6+10;
int res[N], size;
bool vis[N];
inline void solve(int n){
size = 0;
memset( res, 0, sizeof(res));
memset( vis, 0, sizeof(vis));
int x = 1; vis[x] = true;
while( x )
{
x *= 10;
res[size++] = x/n;
x %= n;
if( vis[x] ) break;
vis[x] = true;
}
}
int main(){
int T, n;
scanf("%d",&T);
while( T-- )
{
scanf("%d", &n);
if( n < 0 )
{ printf("-"); n = -n; }
if( n == 1 ) printf("1\n");
else{
size = 0;
memset( vis, 0, sizeof(vis));
int x = 1; vis[x] = true;
while( x )
{
x *= 10;
res[size++] = x/n;
x %= n;
if( vis[x] ) break;
vis[x] = true;
}
//solve(n);
printf( "0." );
for(int i = 0; i < size; i++)
printf("%d",res[i]);
puts("");
}
}
return 0;
}
Problem D
因为N = 1000 , 两两组合后极端情况有 10^6 个值, 排序时间复杂度 Nlog(N) 其中 N = n*n , 又 C组测试数据, 总时间复杂度为 C*n^2*log( n^n)
当 C >= 1000 时, 时间复杂度接近 10^9 , 1,2秒内可能搞不定.
仔细观察, 0 <= a[i] <= 2000 , 那么 0 <= a[i] - a[j] <= 2000 , 当a[ i] >= a[j]时
不同的数值只可能出现 2001 个. 所以我们可以使用 一个 2000的辅助数组 b[2002] 用来记录 | a[i] - a[j] | 的不同结果数量
然后对数组 b[] 从小到大统计到第 k 个就是我们需要的结果了
将 数组 a[] 排序后 可以避免绝对值计算
参考代码:
View Code
#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<iostream>
#include<math.h>
#include<algorithm>
using namespace std;
const int N = 1010;
int a[N],vis[4200],cnt, n, K;
int main()
{
int T;
scanf("%d",&T);
while( T-- )
{
scanf("%d%d",&n,&K);
memset( vis, 0, sizeof(vis));
cnt = 0;
for(int i = 0; i < n; i++)
scanf("%d",&a[i]);
sort( a, a+n );
for(int i = 0; i < n; i++)
for(int j = 0; j < i; j++)
vis[ a[i]-a[j] ] = 1;
int pos = 0;
while(K) K -= vis[pos++];
printf("%d\n", pos-1 );
}
return 0;
}
Problem E
递推题. 我们定义 F[n][m] 为n行m列的矩形数量
因为 n行m列的矩形 是由 n-1行m列 通过增加一行 , 或者 n行m-1列 通过增加一列 得到.
我们现在只考虑 其由 n-1行m列 通过 增加一行 得到.
通过分解. m列, 每一列都增加了一个 1 单位的小矩形.
只对当前一列考虑时 , 其增加了 n 个 ( 考虑 n+1行1列的矩阵, 增加一行则增加了 n个矩形 ), 总共 m 列,则增加了 m*n个矩阵
再考虑两列相邻组合情况,总共有 m-1 个 两两相邻矩阵, 同样是 n个. 总共m-1,则增加了 (m-1)*n
再 3列, 4列 ... m列. 分别是 (m-2)*n . (m-3)*n ... n
累加后, m*n + (m-1)*n + .. + 1*n
提取 公因子n出来后, 可得 n( 1+2+...+m )
然后等差数列求和的到. n*m*(1+m)/2
所以 F[n][m] = F[n-1][m] + n*m*(1+m)/2
预处理 F[1][i] , F[i][1] 的情况然后 预处理就可以了. n, m才100
参考代码
View Code
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
typedef long long LL;
LL f[110][110];
void init()
{
memset( f, 0, sizeof(f));
for(int i = 1; i <= 100; i++)
f[1][i] = f[i][1] = (1+i)*i/2;
for(int i = 2; i <= 100; i++)
for(int j = 2; j <= 100; j++)
f[i][j] = f[i-1][j] + 1LL*i*j*(j+1)/2;
}
int main()
{
init();
int T;
scanf("%d",&T);
while( T-- )
{
int n, m;
scanf("%d%d",&n,&m);
printf("%lld\n", f[n][m]);
}
return 0;
}
Problem F
每一天有士兵死亡,有士兵提供材料进行克隆,有士兵克隆成功.
注意: 士兵生存天数为[1,d] , 可提供克隆材料为生存天数 [1,a] , 培育天数为 [0,k] , 第 k 天培育成功后, k+1 天可以执行任务和提供材料.
这里士兵生存天数和提供克隆材料都是1开始, 是因为对于克隆培育来说, 当第 k 天培育成功后, 相对于 士兵生存天数与提供克隆材料为 第0天.
当k+1时,已经是第1天了, 所以我们需要区分开 时间点的相关关系问题.
解题代码:
View Code
#include<stdio.h>
#include<string.h>
#include<stdlib.h>
typedef long long LL;
LL D[110], K[110], A[110], ans;
int n, d, a, k, x;
int main()
{
int T;
scanf("%d", &T);
while( T-- )
{
// 初始n个士兵
// 每个士兵可存活 d 天
// 培育士兵 k 天成功, k+1 天开始执行任务
// 成功克隆后,前 a 天可提取材料
scanf("%d%d%d%d%d",&n,&d,&a,&k,&x);
memset( D, 0, sizeof(D) );
memset( K, 0, sizeof(K) );
memset( A, 0, sizeof(A) );
//初始化第0天的状态
D[1] = 0; //目前存活了0天的士兵数量
A[1] = 0; //可提取材料的士兵
K[k] = n; //第0天培育成功n个士兵,并在下一天执行任务
ans = 0;
for(int day = 1; day <= x; day++)
{
LL s1 = 0, s2 = 0;
for(int i = k; i >= 0; i-- )
K[i+1] = K[i];
for(int i = d; i >= 1; i-- )
D[i+1] = D[i];
for(int i = a; i >= 1; i-- )
A[i+1] = A[i];
//培养士兵k+1天开始执行任务并提供材料
D[1] = A[1] = K[k+1];
for(int i = 1; i <= d; i++)
s1 += D[i];
ans += s1*5;
//提取材料
for(int i = 1; i <= a; i++)
s2 += A[i];
K[0] = s2;
}
printf("%lld\n", ans );
}
return 0;
}
Problem G
貌似这套题出题人有点缺心眼..
8种模式对比得出下一行的情况.按行匹配就好了.
对于边界我们可以将 0和 m+1 列置为 0 ,这样就简化判断了.
参考代码
View Code
#include<string.h> #include<stdlib.h> #include<algorithm> #include<stdio.h> using namespace std; int dir[8][4]; int mp[1010][1010]; int n, m; char str[1010], tmp[10]; int GetKey(int x,int y,int z){ int a[3] = {x,y,z}; for(int i = 0; i < 8; i++) { bool flag = true; for(int j = 0; j < 3 && flag; j++) { if( dir[i][j] != a[j] ) flag = false; } if( flag ) return i; } } bool legal( int x, int y) { if( (x>=1)&&(x<=n) && (y>=1)&&(y<=m) ) return true; return false; } int main() { int T; scanf("%d", &T); while( T-- ) { scanf("%d", &n); for(int i = 0; i < 8; i++) { scanf("%s %d", tmp, &dir[i][3]); for(int j= 0; j < 3; j++) dir[i][j] = tmp[j]-'0'; } scanf("%s", str); m = strlen( str ); memset( mp, 0, sizeof(mp)); for(int i = 1; i <= m; i++) mp[1][i] = str[i-1]-'0'; for(int i = 1; i < n; i++) for(int j = 1; j <= m; j++) { int k; k = GetKey( mp[i][j-1], mp[i][j], mp[i][j+1] ); mp[i+1][j] = dir[k][3]; } for(int i = 1; i <= n; i++) { for(int j = 1; j <= m; j++) printf("%d",mp[i][j]); puts(""); } } return 0; }
Problem H
哈夫曼编码 : 我们可以这样理解, 对于一个容器, 每一个节点有一个值 (权值), 点与点之间无连接.
每次从容器中取出两个权值最小的顶点 相连 , 并将两个顶点权值和相加后合并成一个顶点放回容器. 如此反复.得出只有一个顶点的情况,
整个过程中 所有合并的和相加,就是 整颗树的权值了.
本题中, 顶点为字母,其出现次数为其权值. 按照上述方法求出后与给定值对比就可以了.
如果使用优先队列,则要注意一个字符的情况的处理
参考代码:
View Code
#include<stdio.h> #include<string.h> #include<stdlib.h> #include<algorithm> #include<queue> using namespace std; priority_queue< int, vector<int>, greater<int> > Q; char str[101010]; int cnt[30]; int main() { int T, n; scanf("%d",&T); while( T-- ) { scanf("%d", &n); scanf("%s", str); memset( cnt, 0, sizeof(cnt)); for(int i = 0; str[i]; i++) cnt[ str[i]-'a' ]++; while( !Q.empty() ) Q.pop(); for(int i = 0; i < 26; i++) if( cnt[i] ) Q.push(cnt[i]); int key = 0; if( Q.size() == 1 ) { key = Q.top(); puts( key <= n ? "yes" : "no"); continue; } while( Q.size() > 1 ) { int a = Q.top(); Q.pop(); int b = Q.top(); Q.pop(); // printf("a = %d, b = %d\n", a, b); key += (a+b); Q.push( a+b ); } puts( key <= n ? "yes" : "no" ); } return 0; }
