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

参考代码: 

#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

　　哈夫曼编码 :   我们可以这样理解, 对于一个容器, 每一个节点有一个值 (权值), 点与点之间无连接.

每次从容器中取出两个权值最小的顶点 相连 , 并将两个顶点权值和相加后合并成一个顶点放回容器. 如此反复.得出只有一个顶点的情况, 

整个过程中 所有合并的和相加,就是 整颗树的权值了.

　　本题中, 顶点为字母,其出现次数为其权值. 按照上述方法求出后与给定值对比就可以了.

　　如果使用优先队列,则要注意一个字符的情况的处理

参考代码:

#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;
}