C++博客-C小加-随笔分类-解题报告

Ural 1880. Psych Up's Eigenvalues（水题）

C小加 — Mon, 07 May 2012 03:15:00 GMT

题意：有3个人

每个人有n个特征值(1 ≤ n ≤ 4 000)

求每个人都有的特征值有几个？(特征值 ≤ 10^9)

分析：我把所有的数据放到一个数组里排序，有连续三个相同的话就是一个共同特征。

#include
#include
#include
using namespace std;
int arr[12003];
int main()
{
    int n;
    scanf("%d",&n);
    int i;
    for(i=0;i    {
        scanf("%d",&arr[i]);
    }
    scanf("%d",&n);
    n+=i;
    for(;i    {
        scanf("%d",&arr[i]);
    }
    scanf("%d",&n);
    n+=i;
    for(;i    {
        scanf("%d",&arr[i]);
    }
    sort(arr,arr+n);
    int cnt=0;
    for(int j=0;j    {
        if(arr[j]==arr[j+1]&&arr[j+1]==arr[j+2])
        {
            ++cnt;
        }
    }
    printf("%d\n",cnt);
    return 0;
}

C小加 2012-05-07 11:15 发表评论

Ural 1787. Turn for MEGA（水题）

C小加 — Mon, 07 May 2012 02:51:00 GMT

题意：k为每分钟可以通行的最大车辆。一共有n个分钟，给出每分钟新出现的车辆数，问过了n分钟后还剩下多少辆车没有通行。

分析：直接模拟就可以了。

#include
#include
using namespace std;

int main()
{
    int k,n;
    scanf("%d %d",&k,&n);
    int sum=0,val;
    for(int i=0;i    {
        scanf("%d",&val);
        sum+=val;
        sum=sum>k?sum-k:0;
    }

    printf("%d\n",sum);

    return 0;
}

C小加 2012-05-07 10:51 发表评论

Uestc 1652 Grab a hole(贪心+枚举)

C小加 — Sun, 06 May 2012 06:50:00 GMT

很遗憾比赛的时候没做出来，当时用贪心的方法写过，可是思路有问题，WA了。解题报告上面只说是贪心，但具体怎么写没有说。于是我就尝试了一些贪心想法，终于AC。24ms的时间还挺靠前的。

题意：N个老鼠洞和N个老鼠，老鼠有个兴趣区间[s,t]，就是说老鼠会对这个范围内的洞感兴趣，他们会占领自己感兴趣的洞。有一个兴趣波动范围K，求一个最小的K使得所有的老鼠都能占领自己感兴趣的洞。

分析：按照左边区间从小到大排序，然后开始枚举每一个区间，从区间右边的端点开始放，如果那个位置已经有老鼠的话，就向前遍历一遍看前边的洞是否已满，没有满的话就向前遍历，遇到左端点的值小于这个老鼠的左端点值时，就交换，直到遇到一个空洞。如果满了的话就向后遍历，遇到右端点大于这个老鼠的右端点时，就交换，直到遇到一个空洞。遍历的时候要时刻判断K的值，如果到达不了那个范围，就增大K的值。

#include
#include
#include
#include
using namespace std;

typedef struct
{
    int s,t;
}ract;
ract r[503];
int line[503];
bool cmp(ract r1,ract r2)
{
    if(r1.s==r2.s) return r1.t    return r1.s}

int main()
{
    int t,pos=0;
    scanf("%d",&t);
    while(t--)
    {
        memset(line,-1,sizeof(line));
        int n;
        scanf("%d",&n);
        for(int i=0;i        {
            scanf("%d %d",&r[i].s,&r[i].t);
        }
        sort(r,r+n,cmp);
        int k=0;
        for(int i=0;i        {
            if(line[r[i].t]==-1)//如果右端点的洞是空的
            {
                line[r[i].t]=i;
            }
            else
            {
                int flag=0,temp=i;
                if(r[i].t>1)
                 for(int j=r[i].t-1;j>=1;--j)//向前遍历，是否已住满
                 {
                     if(line[j]==-1) {flag=1;break;}
                 }
                 if(flag==1)
                for(int j=r[i].t;j>=1;--j)//如果没有住满就向前遍历
                {
                    if(line[j]==-1)//遇到空洞就住下
                    {
                        line[j]=temp;
                        if(r[temp].s>j)
                        k=max(k,r[temp].s-j);//更新K值
                        break;
                    }
                    else if(r[line[j]].s//如果当前洞中的老鼠的左端点小于移动的老鼠的左端点，就交换
                    {
                        int tmp2=line[j];
                        line[j]=temp;
                        if(r[temp].s>j)
                        k=max(k,r[temp].s-j);
                        temp=tmp2;
                    }
                }
                else
                {
                    for(int j=r[i].t;j<=n;++j)//如果已经住满就向后遍历
                    {
                        if(line[j]==-1)
                        {
                            line[j]=temp;
                            if(r[temp].t                            k=max(k,j-r[temp].t);
                            break;
                        }
                        else
                        {
                            if(r[line[j]].t>r[temp].t)
                            {
                                int tmp2=line[j];
                                line[j]=temp;
                                if(r[temp].t                                 k=max(k,j-r[temp].t);
                                 temp=tmp2;
                            }

                        }
                    }
                }
            }

        }
        printf("Case #%d: %d\n",++pos,k);

    }
    return 0;
}

C小加 2012-05-06 14:50 发表评论

poj 3667 NYOJ 534 hotel （区间合并线段树）

C小加 — Fri, 04 May 2012 12:05:00 GMT

区间合并的线段树题，也是我的第一个区间合并。

题意（转）：Bessie等牛到加拿大的桑德贝去增长文化修养外带观赏苏必利尔湖的阳光。按照导游的介绍，Bessie选择了著名的Cumberland大街上的Bullmoose宾馆作为居住的地点。

这座巨型宾馆在一条超长走廊上有N（1 ≤ N ≤ 50000）个排成一排的房间，每个房间都能欣赏到苏必利尔湖的好景色。现在所有的房间都是空的。

现在Bessie等旅客们正在不断地发出订房和退房要求。你需要接受M（1 ≤ M < 50000）条指令：

每条指令的第一个数字为1或2。如果是1，后面将有一个整数D表示顾客要预定的房间数。注意，这些房间必须是连续的。如果能够满足旅客的订房要求，输出满足要求的第一个房间的编号（例如，要订房6间，输出3表示3, 4, 5, 6, 7, 8是满足要求的），这样的编号必须是可能的编号里面最靠前的。如果不能满足要求，输出0。

如果是2，后面将有两个整数X和D表示顾客要退掉X, X + 1, X + 2, ... , X + D - 1这D间房。对于这样的指令什么都不输出。

分析：

分别用lsum，rsum和msum表示区间左边最大连续房间数，区间右边最大连续房间数和区间最大连续房间数。

查询的时候，先找左儿子是否足够，然后如果不够就找左儿子的右区间和右儿子的左区间的和是否足够，如果两个都不够的话就找右儿子（这个时候右儿子就肯定满足了）。

查询结束时要把这个区间的房子更新成已住。

更新的时候和普通的线段树节点更新是一样的，不同的是在更新完子节点后，要把子节点的信息反馈到父节点中。

在NYOJ中提交TLE，原因居然是宏定义比inline快。

#include
#include
#include
#include
#include
using namespace std;
//没想到我把inline换成宏定义后就AC了，理论上这两个一样的，但是inline的结果却是TLE
#define L(r) r<<1
#define R(r) r<<1|1
//inline int MID(int l,int r){return (l+r)>>1;}
//inline int L(int r){return r<<1;}
//inline int R(int r){return r<<1|1;}
const int MAXM=50005;
typedef struct
{
    int lsum,rsum,msum;//分别表示左边最大房间数，右边最大房间数，整体最大房间数
    int cover;//是否住下
}node;
node tree[MAXM<<2];
void pushDown(int root,int m)//向下更新
{
    if(tree[root].cover==-1) return;//是否已经更新
    tree[L(root)].cover=tree[R(root)].cover=tree[root].cover;
    tree[L(root)].msum=tree[L(root)].lsum=tree[L(root)].rsum=tree[root].cover?0:m-(m>>1);
    tree[R(root)].msum=tree[R(root)].lsum=tree[R(root)].rsum=tree[root].cover?0:(m>>1);
    tree[root].cover=-1;
}
void pushUp(int root,int m)//向上更新
{
    tree[root].lsum=tree[L(root)].lsum;
    tree[root].rsum=tree[R(root)].rsum;
    if(tree[root].lsum==m-(m>>1) ) tree[root].lsum+=tree[R(root)].lsum;
    if(tree[root].rsum==(m>>1) ) tree[root].rsum+=tree[L(root)].rsum;
    tree[root].msum=max(tree[R(root)].lsum+tree[L(root)].rsum,max(tree[L(root)].msum,tree[R(root)].msum) );
}
void Create(int l,int r,int root)//建树过程
{
    tree[root].cover=-1;
    tree[root].lsum=tree[root].rsum=tree[root].msum=r-l+1;
    if(l==r){return;}
    int mid=(l+r)>>1;
    Create(l,mid,L(root));
    Create(mid+1,r,R(root));
}
void update(int ll,int rr,int c,int l,int r,int root)//更新
{
    if(ll<=l&&r<=rr)//如果找到这个范围就直接赋值返回，不向下继续更新
    {
        tree[root].msum=tree[root].lsum=tree[root].rsum=c?0:r-l+1;
        tree[root].cover=c;
        return;
    }
    pushDown(root,r-l+1);//用到这个节点的子节点的时候就向下更新
    int m=(l+r)>>1;
    if(ll<=m) update(ll,rr,c,l,m,L(root));
    if(m    pushUp(root,r-l+1);//向下更新完后需要把节点信息反馈给父节点
}
int query(int w,int l,int r,int root)//查询满足连续房间数量的最左节点
{
    if(l==r) return l;
    pushDown(root,r-l+1 );//用到这个节点的子节点的时候就向下更新
    int m=(l+r)>>1;
    if(tree[L(root)].msum>=w) return query(w,l,m,L(root));//如果左儿子满足就询问左儿子
    else if(tree[L(root)].rsum+tree[R(root)].lsum>=w) return m-tree[L(root)].rsum+1;//如果左儿子和右儿子之间的数量满足，则范围左儿子右边连续房间第一个的编号
    return query(w,m+1,r,R(root));//如果两者都不满足则询问右儿子
}

int main()
{
    //freopen("in.txt","r",stdin);
    //freopen("out.txt","w",stdout);
    int n,m;
    while(~scanf("%d %d",&n,&m))
    {
        Create(1,n,1);
        int a,num,x,d,p;
        for(int i=0;i        {
            scanf("%d",&a);
            if(1==a)
            {
                scanf("%d",&num);
                if(tree[1].msum//如果整个区间的最大连续房间数量小于预定的数量就输出0
                else
                {
                    p=query(num,1,n,1);//找到最左节点p
                    printf("%d\n",p);
                    update(p,p+num-1,1,1,n,1);//把已经有人的房间标记一下
                }

            }
            else
            {
                scanf("%d %d",&x,&d);
                update(x,x+d-1,0,1,n,1);//把此范围的房间标记成无人

            }
        }
    }
    return 0;
}

C小加 2012-05-04 20:05 发表评论

NYOJ 290 动物统计加强版（字典树姗姗来迟）

C小加 — Thu, 03 May 2012 08:17:00 GMT

以前学数据结构的时候吧字典树忽视了，导致到现在才学到。
字典树是一种树形的数据结构，插入的复杂度为单词的平均长度。本题只需要写一个插入函数就可以了。
由于过几天就要省赛了，等到省赛后总结一下字典树。

// trietree.cpp : 定义控制台应用程序的入口点。
//
#include
#include
#include<string.h>

using namespace std;
const int num_chars = 26;            //关键码最大位

int _max;
char ans[12];

class Trie
{
public:
    Trie();
    Trie(Trie& tr);
    virtual ~Trie();
    //int trie_search(const char* word, char*entry) const;
    bool insert(const char* word);
protected:
    struct Trie_node   //关键码类型
    {
        bool isfin;
        int cnt;                     //关键码当前位数
        Trie_node* branch[num_chars];   //关键码存放数组
        Trie_node();
    };
    Trie_node* root;
};

Trie::Trie_node::Trie_node()   //结点定义
{
    isfin = false;
    cnt = 0;
    for(int i = 0; i < num_chars;++i)
        branch[i] = NULL;
}

Trie::Trie():root(NULL)
{
}

Trie::~Trie()
{
}

bool Trie::insert(const char*word)
{
    int result = 1,position = 0;
    if(root == NULL)
        root = new Trie_node;
    char char_code;
    Trie_node *location = root;
    while(location != NULL && *word != 0)
    {
        if(*word >= 'a'&& *word <= 'z')
            char_code = *word - 'a';
        if(location->branch[char_code] == NULL)
            location->branch[char_code] = new Trie_node;
        location = location->branch[char_code];
        position++;
        word++;
    }

    ++location->cnt;
    if(location->cnt>_max)
    {
        _max=location->cnt;
        return true;
    }
    else
    return false;
}

int main()
{
    Trie t;
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        _max=0;
        char s[12];
        for(int i=0;i        {
            scanf("%s",s);
            if(t.insert(s))
            {
                strcpy(ans,s);
            }

        }
        printf("%s %d\n",ans,_max);
    }

    return 0;
}

C小加 2012-05-03 16:17 发表评论

poj 1159 Palindrome NYOJ 37 回文字符串(DP)

C小加 — Tue, 10 Apr 2012 13:01:00 GMT

这道题有两种解法：

第一种：求s和~s的LCS，然后套用公式length-LCS长度即为所求。

第二种：直接DP求解。

当s[i] == s[j]时 f[i][j]=f[i+1][j-1]

当s[i] != s[j]时 f[i][j]=min(f[i+1][j],f[i][j-1])+1;

这个题我用的是一个大型的二维数组，代码很水，不建议欣赏。

#include
#include<string>
#include
#include
using namespace std;
const int MAXM=1001;
short int  f[MAXM][MAXM];
char s[1001];
int LCS()
{

    scanf("%s",s);
    memset(f,0,sizeof(f));
    int len=strlen(s);
    for(int i=0;i    {
        for(int j=i;j>=0;--j)
        {
            if(s[i]==s[j])
            {
                f[i+1][j+1]=f[i][j+2];
            }
            else
            {
                f[i+1][j+1]=min(f[i][j+1],f[i+1][j+2])+1;
            }
        }
    }
    return f[len][1];
}

int main()
{
    int n;

    cin>>n;
    while(n--)
    {
        printf("%d\n",LCS());
    }

    return 0;
}

C小加 2012-04-10 21:01 发表评论

poj 1157 LITTLE SHOP OF FLOWERS（简单DP）

C小加 — Tue, 10 Apr 2012 03:23:00 GMT

题意(转)：将某些花放入某些花瓶中得到的观赏价值是不同的，并且要求开始输入的数据必须在后输入的数据前面。即:若一号花放入了3号花瓶，那么后面的花就不能放入1，2号花瓶了。

分析：简单DP。Dp[i][j]表示前i朵花按顺序放入前j 个花瓶中的最优观赏价值。

状态转移方程：dp[i][j]=max(dp[i][j-1],dp[i-1][j-1]+map[i][j])

前i朵花按顺序放入前j 个花瓶中的最优观赏价值=max（前i朵花按顺序放入前j -1个花瓶中的最优观赏价值，前i-1朵花按顺序放入前j -1个花瓶中的最优观赏价值+第i朵花放入j瓶中的价值）

注意价值可能为负数。

#include
#include
using namespace std;
const int INF=0x7fffffff-1;
int map[103][103];
int dp[103][103];
int main()
{
    int f,v;
    scanf("%d %d",&f,&v);

        for(int i=1;i<=f;++i)
        {
            for(int j=1;j<=v;++j)
            {
                scanf("%d",&map[i][j]);
            }
        }
        for(int i=0;i<=f;++i)
        {
            for(int j=0;j<=v;++j)
            {
                dp[i][j]=-INF;
            }
        }
        for(int j=1;j<=v;++j)
        {
            int zc=min(j,f);
            for(int i=1;i<=zc;++i)
            {
                int temp=dp[i-1][j-1]==-INF?0:dp[i-1][j-1];
                dp[i][j]=max(dp[i][j-1],temp+map[i][j]);
            }
        }
        printf("%d\n",dp[f][v]);

    return 0;
}

C小加 2012-04-10 11:23 发表评论

poj 1042 Gone Fishing（贪心+枚举）

C小加 — Fri, 06 Apr 2012 00:13:00 GMT

第一次WA，发现输出格式不对，改掉。

第二次WA，对结果相等的情况没有考虑，改掉。

第三次AC。

题意和题解见黑书P13。

需要注意的是要枚举从第一个湖走到最后一个湖的每一种情况，对结果相等这种情况做特殊处理。

#include
#include
#include
using namespace std;
const int MAXM=30;
int n,h;
int f[MAXM],d[MAXM],t[MAXM];
int each_time[MAXM];
int ans_time[MAXM];
int tf[MAXM];
int ans;
//初始化
void init()
{
    memset(each_time,0,sizeof(each_time));
    memset(ans_time,0,sizeof(ans_time));
    ans=0;
}
//输入
bool input()
{
    init();
    scanf("%d",&n);
    if(0==n) return false;
    scanf("%d",&h);
    for(int i=0;i    {
        scanf("%d",f+i);
    }
    for(int i=0;i    {
        scanf("%d",d+i);
    }
    for(int i=0;i    {
        scanf("%d",t+i);
    }
    return true;
}

void solve(int rem_time,int q)
{
    int tans=0;
    memset(each_time,0,sizeof(each_time));

    memcpy(tf,f,sizeof(f));
    for(int i=0;i//找鱼的数量最多的湖
        {
            int pos=0,max_fish=tf[0];
            if(q>0)
            for(int j=1;j<=q;++j)
            {
                if(max_fish                {
                    max_fish=tf[j];
                    pos=j;
                }
            }
            ++each_time[pos];
            tans+=tf[pos];
            tf[pos]-=d[pos];
            if(tf[pos]<0) tf[pos]=0;

        }
        if(tans>ans)
        {
            ans=tans;
            memcpy(ans_time,each_time,sizeof(each_time));
        }
        else if(tans==ans)//细节，答案相等时做的处理。
        {
            int i;
            for(i=0;i            {
                if(each_time[i]!=ans_time[i]) break;
            }
            if(each_time[i]>ans_time[i])
            {
                memcpy(ans_time,each_time,sizeof(each_time));
            }
        }
}

void print()
{
    printf("%d",ans_time[0]*5);
    for(int i=1;i    {
        printf(", %d",ans_time[i]*5);
    }
    printf("\nNumber of fish expected: %d\n\n",ans);
}
int main()
{
   // freopen("in.txt","r",stdin);
   // freopen("out2.txt","w",stdout);
    while(input())
    {
        int rem_time=h*60;
        rem_time/=5;
        solve(rem_time,0);
        for(int i=0;i//枚举每个湖
        {
            rem_time-=t[i];
            solve(rem_time,i+1);
        }
        print();

    }

    return 0;
}

C小加 2012-04-06 08:13 发表评论

poj 1036 Gangsters (DP)

C小加 — Thu, 29 Mar 2012 03:37:00 GMT

题意：宾馆有个可以伸缩的门，每秒钟可以伸长1个单位，或者缩小1个单位，或者原地不动。有N个强盗，每个强盗会在t的时间内到达并按，如果此时门的开方度和他的身材s正好相等，这个强盗就会进来，然后你就能得到p的加分。

初始状态门是关闭的，让你求出在t时刻得到的最大得分。

分析：按时间从小到大排序，t时间内最大的得分由t之前的时刻决定，满足无后效性，每一个时刻都能得到最优解，满足最有子结构，所以DP。

F[i]表示第i个人。

当身材之差小于时间之差时F[i]=max(f[i],f[j]+ple[i].p) 0<=j但得满足一个条件，第j个人已经进去，否则门伸长的宽度可能会小于身材。

#include
#include
#include
#include
#include
using namespace std;
const int MAXM=103;

typedef struct People
{
    int t,p,s;

}People;
People ple[MAXM];
int f[MAXM];
bool cmp(People p1,People p2)
{
    return p1.t}
int main()
{
    int n,k,s;
    scanf("%d %d %d",&n,&k,&s);
    for(int i=1;i<=n;++i)
        scanf("%d",&ple[i].t);
    for(int i=1;i<=n;++i)
        scanf("%d",&ple[i].p);
    for(int i=1;i<=n;++i)
        scanf("%d",&ple[i].s);
    sort(ple+1,ple+n+1,cmp);
    f[0]=0;
    ple[0].p=0;ple[0].s=0;ple[0].t=0;
    int ans=0;
    for(int i=1;i<=n;++i)
    {
        for(int j=i-1;j>=0;--j)
        {
            if(f[j]>=ple[j].p)//下一步做差的基础是第j个人已经进去。
                if(abs(ple[i].s-ple[j].s)<=ple[i].t-ple[j].t)
                    f[i]=max(f[i],f[j]+ple[i].p);
        }
        ans=max(ans,f[i]);
    }
    printf("%d\n",ans);

    return 0;
}

C小加 2012-03-29 11:37 发表评论

foj 2077 The tallest tree （弱爆了）

C小加 — Tue, 27 Mar 2012 01:24:00 GMT

看了解题报告之后我在想，为什么我会傻傻的去把每一天的高度都求出来。。。。

询问哪一天就求出哪一天的高度，把天数排一下序可以在求的过程中删掉高度和增长速度都小的树。时间复杂度<=O(m*n)。

#include
#include
#include
#include
using namespace std;
typedef long long ll;
const int MAXM=100003;
typedef struct
{
    ll high,add;//高度和增长速度
}Tree;
Tree tree[MAXM];
ll day[MAXM];//实际的数天
ll sday[MAXM];//排序后的天数
ll ans[MAXM];//结果

int main()
{
    int n,m;
    while(scanf("%d %d",&n,&m)!=EOF)
    {
        for(int i=0;i        {
            scanf("%lld %lld",&tree[i].high,&tree[i].add);
        }
        for(int i=0;i        {
            scanf("%lld",day+i);
            sday[i]=day[i];
        }
        sort(sday,sday+m);//天数从小到大排序
        memset(ans,0,sizeof(ans));
        Tree tmax;
        for(int i=0;i//枚举排序后的天数
        {
            tmax.high=tree[0].high+sday[i]*tree[0].add;
            tmax.add=tree[0].add;
            int pos=1;
            for(int j=1;j//枚举每一颗树
            {
                Tree temp=tree[j];
                temp.high+=sday[i]*tree[j].add;
                if( !(tmax.high>=temp.high&&tmax.add>=temp.add) )//如果第j棵树在sday[i]的高度和增长速度都小于某棵树，则舍弃第j棵树
                {
                    tree[pos++]=tree[j];
                }
                //找到在sday[i]时刻高度最大的树
                if(tmax.high                {
                    tmax=temp;
                }
            }
            n=pos;
            ans[ sday[i] ]=tmax.high;
        }

        for(int i=0;i            printf("%lld\n",ans[ day[i] ]);

    }

    return 0;
}

C小加 2012-03-27 09:24 发表评论

foj 2072 Count（二分查找）

C小加 — Mon, 26 Mar 2012 04:32:00 GMT

比赛的时候手写的二分，总是RE。边界处理的能力还有待加强。

看了解题报告之后感觉自己弱爆了，知道方法的题都写不出来。而且当时还是用的map写的，悲剧的超时了。改用vector就过了。

把每个数字出现的位置存储下来，然后对所求的位置进行两次二分，就OK了。用的是stl里的二分，没想到迭代器还可以这样用。

#include
#include
#include
#include
#include
#include
using namespace std;
vector<int> m[100003];

int main()
{

    int n,q;
    while(scanf("%d %d",&n,&q)!=EOF)
    {
        for(int i=0;i<100003;++i)
            m[i].clear();
        int val,l,r,x;
        for(int i=1;i<=n;++i)
        {
            scanf("%d",&val);
            m[val].push_back(i);
        }
        for(int i=1;i<=q;i++)
        {
            scanf("%d %d %d",&l,&r,&x);
            if(m[x].size()!=0)
                if( *(--m[x].end())r )
                    printf("0\n");
                else
                {
                    int ans=( (--upper_bound(m[x].begin(),m[x].end(),r))-m[x].begin() )-( lower_bound(m[x].begin(),m[x].end(),l)-m[x].begin() )+1;
                    printf("%d\n",ans);
                }

            else printf("0\n");
        }
     }

    return 0;
}

C小加 2012-03-26 12:32 发表评论

hdu 1069 Monkey and Banana NYOJ 232 （简单DP）

C小加 — Fri, 23 Mar 2012 02:37:00 GMT

题意：把给定尺寸的长方体（数量不限）叠加在一起，叠加的条件是，上面一个长方体的长和宽比下面长方体的长和宽短，不能相等，长方体可以任意面朝下摆放，求这些长方体能叠加的最高的高度。

把每个长方体分成3个元素。然后就和矩形嵌套差不多了，排序之后求容量最大的子序列。

#include
    #include
    #include
    #include
    using namespace std;

    typedef struct
    {
        int l,w,h;
    }Cub;
    Cub cub[31*3];
    int n;
    int cnt;
    int f[31*3];
    bool cmp(Cub c1,Cub c2)
    {
        if(c1.l==c2.l) return c1.w        return c1.l    }

    bool input()
    {
        scanf("%d",&n);
        if(!n) return false;
        cnt=0;
        int l,w,h;
        for(int i=0;i        {
            scanf("%d %d %d",&l,&w,&h);
            cub[cnt].h=l;
            cub[cnt].w=w>h?h:w;
            cub[cnt].l=w>h?w:h;
            cnt++;
            cub[cnt].h=w;
            cub[cnt].w=l>h?h:l;
            cub[cnt].l=l>h?l:h;
            cnt++;
            cub[cnt].h=h;
            cub[cnt].w=l>w?w:l;
            cub[cnt].l=l>w?l:w;
            cnt++;
        }
        return true;
    }

    void DP()
    {
        memset(f,0,sizeof(f));
        for(int i=0;i        for(int i=1;i        {
            for(int j=0;j            {
                if((cub[i].l!=cub[j].l)&&(cub[i].w>cub[j].w))
                {
                    f[i]=max(f[i],f[j]+cub[i].h);
                }

            }
        }
    }

    void print()
    {
        static int pos=0;
        int ans=0;
        for(int i=0;i        ans=max(f[i],ans);
        printf("Case %d: maximum height = %d\n",++pos,ans);
    }

    int main()
    {
        while(input())
        {
            sort(cub,cub+cnt,cmp);
            //for(int i=0;i            //    printf("%d %d %d\n",cub[i].l,cub[i].w,cub[i].h);
            DP();
            print();

        }

        return 0;
    }

C小加 2012-03-23 10:37 发表评论

NYOJ 110 剑客决斗（简单DP）

C小加 — Thu, 22 Mar 2012 02:30:00 GMT

细节没有处理好，导致超时了好多次。

对于i和j中间的k，如果i和j能遇见k，i能打败k或者j能打败k，则i就能遇见j，用f[i][j]表示i和j是否能遇见。如果i最终能遇见自己，那么i就有取得胜利的可能。

没有开大数组的必要，直接取余就可以。得看明白那些是最优子结构，否则你没办法DP。

时间复杂度为O(n^3)

//NYOj110
//Time:732 Memory:720
#include
#include
#include
//#include<>
using namespace std;

bool a[503][503];
bool f[503][503];

int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        int n;
        scanf("%d",&n);
        for(int i=0;i        {
            for(int j=0;j            {
                scanf("%d",&a[i][j]);
            }
        }
        memset(f,0,sizeof(f));
        for(int i=0;i        {
            f[i][(i+1)%n]=1;
        }
        for(int i=2;i<=n;i++)
        {
            for(int j=0;j            {
                int e=(j+i)%n;
                if(f[j][e]) continue;
                for(int k=(j+1)%n;k!=e;k++,k%=n)
                {
                    if(f[j][k]&&f[k][e]&&(a[j][k]||a[e][k]))
                    {
                        f[j][e]=1;
                        break;
                    }
                }
            }
        }
        int ans=0;
        for(int i=0;i        {
            if(f[i][i]) ans++;
        }
        printf("%d\n",ans);
    }
    return 0;
}

C小加 2012-03-22 10:30 发表评论

poj 2411 Mondriaan's Dream（状态压缩DP）

C小加 — Wed, 21 Mar 2012 11:41:00 GMT

又是周伟大牛论文里的例题。曾经做过一个只有两行的题，很水的DP。矩阵加大后状态也增加了很多，很自然的就用到了状态压缩。

但是，看了discuss之后觉得自己又一次弱爆了，那25行的代码写的都是神马啊，看来只有膜拜的份了。还是先写好状态压缩吧。

起初自己不会DFS，看了某位大牛的解题报告，理解了DFS并且表示这位大牛的DFS写的太强大了，哦还有，周伟大牛的论文太强大了，哦还没完，状态压缩后的二进制表示法太强大了，简简单单的0和1就把所有的状态就搞定了。

发现vector在这里用很合适。

大牛博客地址：http://www.cppblog.com/sdfond/archive/2009/07/31/91761.html

难点：1、DFS寻找状态的过程。2、状态向上凸出和向下凸出的处理。

//poj 2411
//Time: 16MS Memory:1032K

#include
#include
#include
#include
using namespace std;
int m,n;
vector<int> v[1<<11];
long long f[13][1<<11];
//初始化
void init()
{
    for(int i=0;i<(1<<11);i++) v[i].clear();
    memset(f,0,sizeof(f));
}
//输入
bool input()
{
    scanf("%d %d",&m,&n);
    if(m    if(m&&n) return true;
    else return false;
}
//寻找状态
void DFS(int x,int s1,int s2)//s1是s2的上一行状态
{
    if(x>=n)
    {
        if(s1<(1<         v[s2].push_back(s1);
         return;
    }
    DFS(x+1,s1<<1|1,s2<<1);//s1为1，s2为0表示竖着摆放
    DFS(x+1,s1<<1,s2<<1|1);//s1为0表示竖着摆放的下半段，s2为1表示竖着摆放的上半段和横着摆放的半段
    DFS(x+2,s1<<2|3,s2<<2|3);//s1和s2都横着摆放，或者s1横着放,s2为两个竖着摆放的上半段
}
//DP
void DP()
{
    int total=1<    f[0][0]=1;//第0行的状态，全0表示此行已经被占满，不允许第一行向上凸出
    for(int i=1;i<=m+1;i++)
        for(int j=0;j            for(int k=0;k                f[i][j]+=f[i-1][v[j][k]];
}
//输出
void print()
{
    printf("%I64d\n",f[m+1][(1<//第m+1行为全1状态，表示第m行没有凸出来的状态。
}
int main()
{
    while(input())
    {
        init();
        DFS(0,0,0);
        DP();
        print();

    }
    return 0;
}

C小加 2012-03-21 19:41 发表评论

WA used long long,AC used __int64

C小加 — Wed, 21 Mar 2012 01:37:00 GMT
The output should be printf in %I64d ,or you will get WA.
Because the server system is windows.

C小加 2012-03-21 09:37 发表评论

poj 1185 炮兵阵地（状态压缩DP）

C小加 — Tue, 20 Mar 2012 13:11:00 GMT

弱爆了。我调试了一个下午加半个晚上，最后重写了一遍AC了。2xx ms的时间，在自己oj上排倒数第一。

我的第二道状态压缩DP，也是周伟论文《状态压缩》里的一道例题，核心思想这篇论文分析的很清楚，建议学习状态压缩的同学一定要看一下。

这道题做的很过瘾，收获很多，各种二进制的解法。还有状就是态数的求法也很强，刚开始写的时候还准备DFS呢，后来大牛告诉我直接枚举所有状态进行删除就可以了，好吧，删除的判断又是二进制。

#include
#include
#include
using namespace std;
const int MAXM=63;
int e[103];
int m,n;
int s[MAXM];
int c[MAXM];
int f[103][MAXM][MAXM];
int cnt;
//输入数据
void input()
{
    memset(e,0,sizeof(e));
    char str[13];

    for(int i=0;i    {
        scanf("%s",str);
        for(int j=0;j        {
            if(str[j]=='H') e[i]=(e[i]<<1)|1;
            else e[i]=e[i]<<1;
        }
    }
}
//比较左右间隔是否为2
bool fit(int x)
{
    if( x & (x<<1) ) return false;
    if( x & (x<<2) ) return false;
    return true;
}
//二进制中1的个数
int num1(int x)
{
    int count=0;
    while(x>0)
    {
        count++;
        x= x & (x-1);
    }
    return count;
}
//寻找状态数
void DFS()
{
    int total=1<    for(int i=0;i    {
        if(fit(i))
        {
            s[++cnt]=i;
            c[cnt]=num1(i);
        }
    }
}
//DP
void DP()
{
    //初始化
    memset(f,-1,sizeof(f));
    for(int i=0;i<=cnt;++i)
    {
        if(s[i]&e[0])continue;
        f[0][i][0]=c[i];
    }

    for(int i=1;i    {
        for(int j=0;j<=cnt;++j)
        {
            if(s[j]&e[i])continue;
            for(int k=0;k<=cnt;++k)
            {
                if(s[j]&s[k])continue;
                for(int l=0;l<=cnt;++l)
                {
                    if(s[j]&s[l]) continue;
                    if(f[i-1][k][l]==-1) continue;
                    f[i][j][k]=max(f[i][j][k],f[i-1][k][l]+c[j]);
                }
            }
        }
    }
}
//输出
void print()
{
    int ans=0;
    if(m!=0)
    for(int i=0;i<=cnt;i++)
        for(int j=0;j<=cnt;j++)
            ans=max(ans,f[m-1][i][j]);
    printf("%d\n",ans);
}

int main()
{
    //freopen("in.txt","r",stdin);

    while(scanf("%d %d",&m,&n)!=EOF)
    {
        cnt=-1;
        input();
        DFS();
        DP();
        print();

    }

    return 0;
}

C小加 2012-03-20 21:11 发表评论

sgu 223 Little Kings（状态压缩DP）

C小加 — Tue, 20 Mar 2012 03:34:00 GMT

第一个状态压缩啊，调试了一个上午，终于过了，国王的个数原来是从0开始循环的。

周伟大神的论文《状态压缩》很给力，如果不是这篇论文，我都不知道该如何入门了。哎，没人教的杯具。

本题题解《状态压缩》讲的很清楚，我就不多废话了。需要注意的是范围会超int，还有对状态的范围要把握好，搞不好你也要杯具去各种调试了。

自己写的DFS很挫，借用了不知道哪位大牛的DFS。

#include
#include
#include
using namespace std;
const int MAXM=520;
int n,k;
int s[MAXM];//状态数
int c[MAXM];//1的个数
long long f[13][MAXM][103];
int ck;
void dfs(int x,int val,int cnt)//DFS寻找每行的状态数
{
    if(x==n)
    {
        s[++ck]=val;
        c[ck]=cnt;
        return;
    }
    dfs(x+1,val<<1,cnt);
    if(!(val&1))
    dfs(x+1,val<<1|1,cnt+1);
}
bool cont(int s1,int s2)//判断与题意是否矛盾
{
    if(s1&s2) return false;//和正上方判断
    if(s1&(s2<<1))return false;//和右上方判断
    if(s1&(s2>>1))return false;//和左上方判断
    return true;
}
void dp()
{
        //初始化状态
        memset(f,0,sizeof(f));
        f[0][1][0]=1;
        //dp
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=ck;j++)
            {
                for(int g=1;g<=ck;g++)
                {
                    for(int p=0;p<=k;p++)
                    {
                        if((p-c[j]>=0)&&cont(s[j],s[g]))
                        f[i][j][p]+=f[i-1][g][p-c[j]];
                    }
                }
            }
        }
}

int main()
{
    while(scanf("%d %d",&n,&k)!=EOF)
    {
        ck=0;
        dfs(0,0,0);
        dp();
        long long ans=0;

        for(int i=1;i<=ck;++i)
        {
            ans+=f[n][i][k];
        }

        printf("%I64d\n",ans);

    }

    return 0;
}

C小加 2012-03-20 11:34 发表评论

NYOJ 475 Doctor's order (逆序数)

C小加 — Mon, 19 Mar 2012 05:43:00 GMT

大意：两个垂直于x轴的直线lx和rx围成的区域。有n条直线穿过这片区域，每条直线yi=kxi+b，给出k和b。求直线把这个区域分成了几个部分。三条直线不会交于一点（包括：两个垂直于x轴的直线）。

画图可以找出一种关系，分成的区域数=交点数+线段数+1；对左端点从大到小排序，然后对右端点求逆序数，逆序数就是交点数，线段数已知，空间数就出来了。

#include
#include
#include
using namespace std;
const int MAXM=30004;
const int INF=0x7fffffff-1;
typedef struct
{
    int y1,y2;
}Line;
Line line[MAXM];
int temp1[MAXM/2+1];
int temp2[MAXM/2+1];
int cnt;
bool cmp(Line l1,Line l2)
{
    return l1.y1>l2.y1;
}
void merge(int start,int mid,int end)
{
    int n1,n2;
    n1=mid-start+1;
    n2=end-mid;
    for(int i=0;i    temp1[i]=line[start+i].y2;
    for(int i=0;i    temp2[i]=line[mid+i+1].y2;
    temp1[n1]=-INF;
    temp2[n2]=-INF;
    for(int k=start,i=0,j=0;k<=end;k++)
    {
        if(temp1[i]>=temp2[j])
        {
            line[k].y2=temp1[i];
            i++;
        }
        else
        {
            cnt+=n1-i;//求逆序数
            line[k].y2=temp2[j];
            j++;
        }
    }

}
//归并排序
void mergesort(int start,int end)
{
    if(start>=end) return;
    int mid=(end+start)/2;
    mergesort(start,mid);
    mergesort(mid+1,end);
    merge(start,mid,end);

}

int main()
{
    int lx,rx;
    while(scanf("%d%d",&lx,&rx)!=EOF)
    {
        cnt=0;
        int n,k,b;
        scanf("%d",&n);
        for(int i=0;i        {
            scanf("%d%d",&k,&b);
            line[i].y1=lx*k+b;
            line[i].y2=rx*k+b;

        }
        sort(line,line+n,cmp);//对左端点从大到小排序
        mergesort(0,n-1);
        printf("%d\n",cnt+n+1);//空间数=交点数+线段数+1

    }
    return 0;
}

C小加 2012-03-19 13:43 发表评论

zoj 3578 NYOJ 472 Matrix （水题）

C小加 — Mon, 19 Mar 2012 05:36:00 GMT

一直认为是二维线段树，看了解题报告后居然是水题。

最多1000个矩形。每次扫描矩形与之前的矩形是否相交，在相交的矩形中找到一个最大的值max，让这个max加上h就是这次矩形的值。每次向回扫描一遍，最高也就1000*1000的时间，1s内绝对没问题。

#include
#include
using namespace std;

typedef struct
{
    int x1,y1,x2,y2,_max;
}Matrix;
Matrix matrix[1003];

bool cover(int i,int j)//是否相交
{
    if(matrix[i].x1>=matrix[j].x2||matrix[j].x1>=matrix[i].x2) return false;
    if(matrix[i].y1>=matrix[j].y2||matrix[j].y1>=matrix[i].y2) return false;
    return true;
}

int main()
{
    int N,M,C;
    while(scanf("%d %d %d",&N,&M,&C)!=EOF)
    {
        int ans=0;
        int a,b,h,x,y;
        for(int i=0;i        {
            int tmax=0;
            scanf("%d %d %d %d %d",&a,&b,&h,&x,&y);
            matrix[i].x1=x;
            matrix[i].y1=y;
            matrix[i].x2=x+a;
            matrix[i].y2=y+b;
            for(int j=i-1;j>=0;j--)
            {
                if(cover(i,j))
                {
                    tmax=max(tmax,matrix[j]._max);
                }

            }
            matrix[i]._max=tmax+h;
            ans=max(ans,matrix[i]._max);
        }
        printf("%d\n",ans);
    }
    return 0;
}

C小加 2012-03-19 13:36 发表评论

Ural1117. Hierarchy（技巧题，WA了好多次）

C小加 — Wed, 14 Mar 2012 00:48:00 GMT

这道题纠结我了一天的时间，本以为用lowbit可以轻松搞定，可是中间出现了各种故障，WA了很多次才AC。

计算a和b之间的节点数，可以用1-a与1-b的节点数之差来求。在右子树的点可以转化为相应的左子树的点，经过多步骤的转化，可以把点的位置固定在树的最左边的那条线上。所以只需要计算每层最左边的节点数就OK了。经过递推会得出一个公式，z[i]=z[i-1]*2+i-1;i表示树的高度。

#include
#include
#include
using namespace std;
typedef long long ll;
ll z[33]={0};//从1到n经过的点
ll d[33]={0};//树每层最左边的序号
void init()
{
    for(int i=2;i<=31;i++)
    {
        z[i]=z[i-1]*2+i-1;
    }
    d[1]=1;
    for(int i=2;i<=31;i++)
    {
        d[i]=d[i-1]<<1;
    }
}
ll lowbit(ll x)
{
    return x&(-x);
}

//得到数的二进制位数
ll getbit(ll x)
{
    ll cnt=0;
    while(x!=1)
    {
        x>>=1;
        cnt++;
    }
    return cnt;
}
void swap(int& a,int& b)
{
    int temp=a;
    a=b;
    b=temp;
}
ll fun(ll x)
{
    return d[getbit(x)+1];//得到位数对应的二进制数
}
ll solve(ll x)
{
   ll bx=x-lowbit(x);
    if(bx==0)
    {
        return z[getbit(x)];
    }
    else
    {

        int temp=fun(x);
        ll sum=solve(temp)+abs(solve(temp)-solve(temp-(x-temp)));

        return sum;
    }
}

int main()
{
init();
    int a,b;
    while(scanf("%d %d",&a,&b)!=EOF)
    {

        if(a>b) swap(a,b);
        ll ba=solve(a);
        ll bb=solve(b);
        printf("%lld\n",bb-ba);
    }
    return 0;
}

C小加 2012-03-14 08:48 发表评论

Ural 1071. Nikifor 2 解题报告

C小加 — Thu, 08 Mar 2012 07:47:00 GMT
水题。
从k=2开始枚举，一直枚举到x。

#include
#include
using namespace std;

bool comp(int x,int y,int k)
{
        int temp1,temp2;
        while(y!=0)
        {
            temp1=y%k;
            y/=k;
            while(x!=0)
            {
                temp2=x%k;
                if(temp1==temp2)
                break;
                x/=k;
            }
            if(x==0) return false;
            x/=k;
        }

        return true;
}

int main()
{
        int x,y;
        scanf("%d %d",&x,&y);
        int k=2;
        for(;k<=x;k++)
        {
            if(comp(x,y,k)) break;
        }
        if(k>x) printf("No solution\n");
        else printf("%d\n",k);
        return 0;
}

C小加 2012-03-08 15:47 发表评论

hdu 4163 Stock Prices 解题报告

C小加 — Tue, 06 Mar 2012 02:48:00 GMT

水题。

题意：给你每天的股价，让你找出最小的K1个股价，然后按日期从小到大排序输出，找出最大的k2个股价，按日期从大到小输出。

我用了4个sort。

#include
#include
#include
using namespace std;
typedef struct
{
    int p,d;
}Data;
Data dt[1000003];

bool cmp1(Data d1,Data d2)
{
    if(d1.p==d2.p) return d1.d    return d1.p}
bool cmp2(Data d1,Data d2)
{
    if(d1.p==d2.p) return d1.d>d2.d;
    return d1.p>d2.p;
}
bool cmp3(Data d1,Data d2)
{
     return d1.d}
bool cmp4(Data d1,Data d2)
{
     return d1.d>d2.d;
}
void print()
{
    static int cnt=0;
    printf("Case %d\n",++cnt);
}
int main()
{
    int n,k1,k2;
    while(scanf("%d %d %d",&n,&k1,&k2),n&&k1&&k2)
    {
        for(int i=0;i        {
            scanf("%d",&dt[i].p);
            dt[i].d=i+1;
        }
        sort(dt,dt+n,cmp1);//从小到大排序
        print();//忽略
        sort(dt,dt+k1,cmp3);//日期的字典序从小到大
        printf("%d",dt[0].d);
        for(int i=1;i        printf(" %d",dt[i].d);
        printf("\n");
        sort(dt,dt+n,cmp2);//从大到小排序
        sort(dt,dt+k2,cmp4);//日期的字典序从大到小
        printf("%d",dt[0].d);
        for(int i=1;i        printf(" %d",dt[i].d);
        printf("\n");

    }
    return 0;
}

C小加 2012-03-06 10:48 发表评论

hdu 4165 Pills 解题报告

C小加 — Mon, 05 Mar 2012 05:49:00 GMT

DP或卡特兰数。

弱爆了。做题的时候只想着用一个状态去做，结果悲剧了。后来成哥提醒用二维的，我才发现得用两个状态去写。哎，怎么没想到两个状态呢。
题意：在一个瓶子里有N片药，每次吃半片，从瓶子里可能拿出整片，也可能拿出半片，如果拿出整片，记为W，半片记为H。问有多少种排列。

第一个状态：完整药片的数量。第二个状态：半片药片的数量。

F（i，j）=f（i-1,j+1）+f（I，j-1）；

当吃的是整片时，i-1，半片的增加一个，j+1。

当吃的是半片时，i不变，j-1。

用两个状态写的时候这个题就很水了。不过提交的时候在g++下用lang lang WA，改成int64在C++下提交就AC了。很是不解。

卡特兰数的方法就不多说了。。。。你懂的。。
#include
#include
#include
using namespace std;
__int64 f[33][33];

int main()
{
    memset(f,0,sizeof(f));
    int k=30;
    for(int i=0;i    for(int i=2;i<=30;i++)
    {
        k--;
        f[i][0]=f[i-1][1];
        for(int j=1;j        {
            f[i][j]=f[i][j-1]+f[i-1][j+1];
        }
    }

   int s;
   while(scanf("%d",&s),s)
   {
       printf("%I64d\n",f[s][0]);
   }
    return 0;
}

C小加 2012-03-05 13:49 发表评论

Ural 1098. Questions 解题报告

C小加 — Fri, 02 Mar 2012 09:09:00 GMT

题看不懂，在网上找到的翻译。就是整个串（不是整行）的约瑟夫环。

#include
#include
using namespace std;

char str[30003];
int Josephus(int n,int m,int k ) //分别为：人数，出圈步长，起使报数位置,
{
     int x=1;

     if (m == 1)
         k = k == 1 ? n : (k + n - 1) % n;
             else{
                 for (int i = 1; i <= n; i++)
                 {
                     if ((k + m) < i)
                     {
                         x = (i - k + 1) / (m - 1) - 1;
                         if (i + x < n){
                             i = i + x;
                             k = (k + m * x);
                         }
                         else{
                             k = k + m * (n - i) ;
                             i = n;
                         }
                    }
                    k = (k + m - 1) % i + 1;
                }
           }
      return k; //返回最后一人的位置
}

int main()
{
     //freopen("in.txt","r",stdin);
     int len=0;
    while(scanf("%c",&str[0])!=EOF)
    {
        if(str[0]>=' ')
        str[++len]=str[0];
    }
    int k=Josephus(len,1999,1);
    if (str[k]=='?')
    printf("Yes\n");
    else if (str[k]==' ')
    printf("No\n");
     else
      printf("No comments\n");

     return 0;
}

C小加 2012-03-02 17:09 发表评论

Ural1095. Nikifor 3 解题报告

C小加 — Thu, 01 Mar 2012 05:50:00 GMT

题目保证至少有一个1、2、3、4。说明这四个数是一个突破点。由此可以联想到以1、2、3、4四个数字结尾的数保证能被7整除。这样不论前边的数怎样排列，后边四个数总有一种组合能够保证整体可以被7整除。

#include
#include
#include
using namespace std;
const int z[7]={4123,1324,1234,2341,1243,3421,3142};
char s[23];
int ns[23];
int num0_9[10];
int atoi(char s)
{
    return s-'0';
}
int fun(int x,int num)//把前边的数排列成新数
{
    for(int i=0;i    {
        ns[x+i]=num;
    }
    return x+num0_9[num];
}
int fun2(int x)//求前边的数除以7的余数
{
    int yu=0;
    for(int i=0;i    {
        yu=(yu*10+ns[i])%7;
    }
    return yu;
}
int main()
{
    int t;
    scanf("%d",&t);
    while(t--)
    {
        memset(num0_9,0,sizeof(num0_9));
        scanf("%s",s);
        int slen=strlen(s);
        //统计每个数的个数
        for(int i=0;i        {
          int num=atoi(s[i]);
          num0_9[num]++;
        }
        //减去1、2、3、4
        for(int i=1;i<=4;i++)
        {
            num0_9[i]--;
        }
        //求前边组成的新数
        int x=0;
        for(int i=1;i<=9;i++)
        {
            x=fun(x,i);
        }
        int yu=fun2(x);//求新数除以7的余数
        int i;
        //找到一种组合可以与前边的数组合起来被7整除
        for(i=0;i<7;i++)
        {
            if((yu*10000+z[i])%7==0)
            {
                break;
            }
        }
        //输出，后边可以补上0
        for(int j=0;j        printf("%d",ns[j]);
        printf("%d",z[i]);
        for(int j=0;j        printf("0");
        printf("\n");

    }

    return 0;
}

C小加 2012-03-01 13:50 发表评论

zoj 3576 NYOJ 470 Count the Length 解题报告

C小加 — Wed, 29 Feb 2012 13:03:00 GMT

简单数学。

题意是给定长和宽，求对角线红色区域的长度和。

把m,n都除以他们的最大公约数t，使tm=m/t,tn=n/t，新tm，tn所组成的矩形的对角线长度*t就是原矩形的对角线长度。

把对角线平均分成tm*tn条线段，对角线与每条线段的交点必在tm*tn份中的线段的端点上（可利用相似三角形证明，这里省略）。

观察可以看出如果tm和tn有一个是偶数，则红色线段的数量和蓝色线段的数量相等，如果tm和tn都是奇数，则红色线段的数量=蓝色线段的数量+1，这样根据比例就可以求出红色线段的长度了。
#include
#include
#include
using namespace std;
typedef long long ll;
ll gcd(ll m,ll n)
{
    if(!n) return m;
    return gcd(n,m%n);
}
int main()
{
    ll m,n,tm,tn,t;
    while(scanf("%lld %lld",&m,&n)!=EOF)
    {
        tm=m>n?m:n;
        tn=m        t=gcd(m,n);
        tm/=t;
        tn/=t;
        if(tm%2==0||tn%2==0)
        {
            printf("%.3lf\n",sqrt((double)(tm*tm+tn*tn))/2*t);
            continue;
        }

        double ans;
        ans=sqrt((double)(tm*tm+tn*tn))*(tm*tn+1)/(2*tm*tn)*t;
        printf("%.3lf\n",ans);
    }
    return 0;
}

C小加 2012-02-29 21:03 发表评论

zoj 3573 Under Attack 解题报告

C小加 — Sun, 26 Feb 2012 02:35:00 GMT

巧妙数组或者一维线段树。
比赛时没有仔细看题，结束标记写错了，导致TLE了两次。大致意思是，线段树长度[0,len]，初始化为0，插入区间增量，最后求两个最大值的位置，一个是从左到右的最大值（遇到的第一个最大值即为所求），一个是从右到左的最大值。
好长时间没写线段树的原因，导致我直接上模板了，结构体变量有点多，写的不是很好，代码很长。正式比赛中第一个线段树。
后来听说有O（n）的算法，突然就想起来了学校oj上有一道巧妙运用数组的题，然后感觉用数组可以搞，试了一下AC掉了，时间1900+，比线段树的5000+少多了。。
。
数组代码：
#include
#include
#include
using namespace std;
const int MAXM=15003;
int a[MAXM];

int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
   {
       int l,r,b;
       memset(a,0,sizeof(a));
       while(scanf("%d %d %d",&l,&r,&b))
       {
           if(l==-1) break;
           a[l]+=b;
           a[r+1]-=b;
       }
       int lmax=a[0],posl=0;
       for(int i=1;i<=n;i++)
       {
           a[i]+=a[i-1];
           if(lmax           {
               lmax=a[i];
               posl=i;
           }
       }
       int posr;
       for(int i=n;i>=0;i--)
       {
           if(a[i]==lmax)
           {
               posr=i;
               break;
           }
       }
       printf("%d %d\n",posl,posr);
   }

    return 0;
}

线段树代码：

#include
#include
using namespace std;
inline int L(int r){return r<<1;}
inline int R(int r){return (r<<1)+1;}
inline int MID(int l,int r){return (l+r)>>1;}
const int MAXN=15003;
typedef struct
{
    int left,right;
    int _max,posl,posr;
    int add;
}Node;
Node tree[MAXN*4];
//int arr[MAXN];
void Create(int l,int r,int root)
{
    tree[root].left=l;
    tree[root].right=r;
    if(l==r)
    {
        tree[root]._max=0;
        tree[root].posl=l;
        tree[root].posr=r;
        tree[root].add=0;
        return;
    }
    int mid=MID(l,r);
    Create(l,mid,L(root));
    Create(mid+1,r,R(root));
    tree[root]._max=0;
    tree[root].posl=l;
    tree[root].posr=r;
    tree[root].add=0;
}
void Update_info(int node)
{
    if(tree[node].add)
    {
        tree[L(node)].add+=tree[node].add;//更新子树时会用到
        tree[R(node)].add+=tree[node].add;
        tree[L(node)]._max+=tree[node].add;
        tree[R(node)]._max+=tree[node].add;
        tree[node].add=0;
    }
}

void Updata(int l,int r,int val,int root)
{
    if(l<=tree[root].left&&tree[root].right<=r)
    {
        tree[root].add+=val;
        tree[root]._max+=val;
        return;
    }
    Update_info(root);
    if(tree[root].left==tree[root].right) return;
    int mid=(tree[root].left+tree[root].right)>>1;
    if(l>mid) Updata(l,r,val,(root<<1)+1);
    else if(r<=mid) Updata(l,r,val,root<<1);
    else
    {
        Updata(l,mid,val,root<<1);
        Updata(mid+1,r,val,(root<<1)+1);
    }
    if(tree[L(root)]._max>tree[R(root)]._max)
    {
        tree[root]._max=tree[L(root)]._max;
        tree[root].posl=tree[L(root)].posl;
        tree[root].posr=tree[L(root)].posr;
    }
    else if(tree[L(root)]._max==tree[R(root)]._max)
    {
        tree[root]._max=tree[L(root)]._max;
        tree[root].posl=tree[L(root)].posl;
        tree[root].posr=tree[R(root)].posr;
    }
    else
    {
        tree[root]._max=tree[R(root)]._max;
        tree[root].posl=tree[R(root)].posl;
        tree[root].posr=tree[R(root)].posr;
    }
}

int main()
{
    int n;
    while(scanf("%d",&n)!=EOF)
    {
        int l,r,b;
        Create(0,n,1);
        while(scanf("%d %d %d",&l,&r,&b))
        {
            if(l==-1) break;
            Updata(l,r,b,1);
        }
        printf("%d %d\n",tree[1].posl,tree[1].posr);
    }

    return 0;
}

C小加 2012-02-26 10:35 发表评论

Ural 1119. Metro NYOJ 195 飞翔解题报告

C小加 — Sat, 25 Feb 2012 00:50:00 GMT

DP。

１、每一行最多只可以走一次捷径，每一列也是最多只可以走一次捷径

２、每次走过捷径后的横坐标和纵坐标都要大于之前的坐标

只要求出从起点到终点所经过的最多的捷径，就能得到最少的路程。每一步的最优解用之前走过的路径所求，满足无后效性，每一个子状态都可以求出最优解，满足最优子结构，可以用dp解决。

f[i]=max(f[j]+1,f[i]);

当j点坐标小于点，i点为捷径时，走到i点坐标时经过的最多捷径数=max(走到j点的最多捷径数+1，走到i点时的最多捷径数)

最后找出最大的f(i)就是能经过最多的捷径

注意坐标的输入没有顺序性，要进行排列。

#include
#include
#include
#include
#include
using namespace std;
const int MAXN=1003;
typedef struct
{
    int a,b;
}point;
point p[MAXN];
int f[1003];
bool cmp(point p1,point p2)
{
    if(p1.a==p2.a) return p1.b    return p1.a}
int main()
{
    //freopen("1.in","r",stdin);
    int m,n;
    while(cin>>n>>m)
    {
        int k;
        cin>>k;
        for(int i=0;i        {
            cin>>p[i].a>>p[i].b;
            f[i]=1;
        }
        sort(p,p+k,cmp);//如果横坐标相等，按照纵坐标从小到大排序，否则按照横坐标从小到大排序
        int v=0,flag=0;

        //dp
        for(int i=0;i        {
            for(int j=0;j<=i;j++)
            {
                if(p[i].a>p[j].a)
                {
                    if(p[i].b>p[j].b) f[i]=max(f[j]+1,f[i]);
                }
            }

        }
        //求用到最多捷径的点
        int ma=*max_element(f,f+k);
        cout<<(int)((m+n-2*ma)*100+ma*100*sqrt(2.0)+0.5)<
    }

    return 0;
}


C小加 2012-02-25 08:50 发表评论

Ural 1146. Maximum Sum NYOJ 104 最大和解题报告

C小加 — Fri, 24 Feb 2012 08:58:00 GMT

a[i][j]=a[i-1][j]+among;这样存值的话就可以转化成求和最大连续子串

0.031

156 KB

#include
#include
#include
using namespace std;
const int INF=0x7fffffff-1;
int a[103][103];
int main()
{
    memset(a,0,sizeof(a));
    int n,among;
    while(scanf("%d",&n)!=EOF)
    {
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
        {
            scanf("%d",&among);
            a[i][j]=a[i-1][j]+among;
        }
    int ans=-INF;
    for(int i=0;i    {
        for(int j=i+1;j<=n;j++)
        {
            int maxnum=a[j][1]-a[i][1];
            ans=max(maxnum,ans);
            for(int k=2;k<=n;k++)
            {
                if(a[j][k]-a[i][k]+maxnum                {
                    maxnum=a[j][k]-a[i][k];
                    ans=max(maxnum,ans);
                }
                else
                {
                    maxnum+=a[j][k]-a[i][k];
                    ans=max(maxnum,ans);
                }
            }

        }
    }
    printf("%d\n",ans);
    }

    return 0;
}

C小加 2012-02-24 16:58 发表评论

NYOJ 136 等式解题报告

C小加 — Sun, 29 Jan 2012 17:40:00 GMT
哈希。把a1*x1³+a2*x2³的所有情况存储在哈希表中，然后用a3*x3³+a4*x4³+a5*x5³去表中查找和为0的情况。用数组暴力的话会超内存。这个题很久以前做过，虽然AC了但是错的。之前做的时候觉得有一组数据超int了（老是RE），而且当时认为只有这一组数据超了，所以当时就把这组数据进行特殊化处理了。后来小牛找出了问题我才意识到根本没有超出int，我去掉特殊化处理后提交TLE，不是RE，我开始纠结当时到底是怎么做的。
我重新检查了一遍代码，发现我的哈希算法加上那组特殊数据，时间复杂度O（n*m），n达到100万，m达到1万。这时间伤不起啊。后来想想哈希还可以优化，于是我就改了一下哈希算法，复杂度降低到了O（n），最终也顺利AC。

#include
#include
#include
#include
const int MAX=100003;
const int MAXSUM=12500000;
int a[1003];

void g()
{
    for(int i=-50;i<=50;i++)
    {
        a[i+50]=i*i*i;
    }
}

template <class T>
class hash
{
private:

    int pos;
    int next[MAX];
    int head[MAX];
    int key[MAX];
    int cnt[MAX];
public:
    int count;
    void search(const int x);
    bool search1(const int x);
    void push(const int x);
    void clear();

};

template <class T>
inline bool hash::search1(const int x)
{
    int temp=abs(x)%MAX;
    int t=head[temp];
    while(t!=-1)
    {
        if (x==key[t])
        {
            cnt[t]++;
            return true;
        }
        t=next[t];
    }
    return false;
}

template <class T>
inline void hash::search(const int x)
{
    int temp=abs(x)%MAX;
    int t=head[temp];
    while(t!=-1)
    {
        if (x==-key[t])
        {
            count+=cnt[t];
        }
        t=next[t];
    }
}
template <class T>
inline void hash::push(const int x)
{
    if(search1(x)) return;
    int temp=abs(x)%MAX;

    if (head[temp]!=-1)
    {
        next[pos]=head[temp];
    }
    head[temp]=pos;
    key[pos]=x;
    cnt[pos]=1;
    pos++;
}
template <class T>
void hash::clear()
{
    count=0;
    pos=0;
    memset(next,-1,sizeof(next));
    memset(head,-1,sizeof(head));
    memset(cnt,0,sizeof(cnt));
}
hash<int> h;

int main()
{
    //freopen("in.txt","r",stdin);
    int T;
    scanf("%d",&T);
    memset(a,0,sizeof(0));
    g();
    while(T--)
    {

        h.clear();
        int a1,a2,a3,a4,a5;
        int i,j,k;
        int n;
        scanf("%d%d%d%d%d",&a1,&a2,&a3,&a4,&a5);
        for(i=-50;i<=50;i++)
        {

            for(j=-50;i!=0&&j<=50;j++)
            {
                if(j==0) continue;
                n=a1*a[i+50]+a2*a[j+50];
                h.push(n);

            }
        }
        for(i=-50;i<=50;i++)
        {

            for(j=-50;i!=0&&j<=50;j++)
            {
                for(k=-50;j!=0&&k<=50;k++)
                {
                    if(k==0) continue;
                    n=a3*a[i+50]+a4*a[j+50]+a5*a[k+50];
                    if(n > MAXSUM || n < -MAXSUM)
                        continue;
                    h.search(n);
                }
            }
        }

        printf("%d\n",h.count);
    }

    return 0;
}


C小加 2012-01-30 01:40 发表评论

C++博客-C小加-随笔分类-解题报告

Ural 1880. Psych Up's Eigenvalues（水题）

Ural 1787. Turn for MEGA（水题）

Uestc 1652 Grab a hole(贪心+枚举)

poj 3667 NYOJ 534 hotel （区间合并线段树）

NYOJ 290 动物统计加强版（字典树姗姗来迟）

poj 1159 Palindrome NYOJ 37 回文字符串(DP)

poj 1157 LITTLE SHOP OF FLOWERS（简单DP）

poj 1042 Gone Fishing（贪心+枚举）

poj 1036 Gangsters (DP)

foj 2077 The tallest tree （弱爆了）

foj 2072 Count（二分查找）

hdu 1069 Monkey and Banana NYOJ 232 （简单DP）

NYOJ 110 剑客决斗（简单DP）

poj 2411 Mondriaan's Dream（状态压缩DP）

WA used long long,AC used __int64

poj 1185 炮兵阵地 （状态压缩DP）

sgu 223 Little Kings（状态压缩DP）

NYOJ 475 Doctor's order (逆序数)

zoj 3578 NYOJ 472 Matrix （水题）

Ural1117. Hierarchy（技巧题，WA了好多次）

Ural 1071. Nikifor 2 解题报告

hdu 4163 Stock Prices 解题报告

hdu 4165 Pills 解题报告

Ural 1098. Questions 解题报告

Ural1095. Nikifor 3 解题报告

zoj 3576 NYOJ 470 Count the Length 解题报告

zoj 3573 Under Attack 解题报告

Ural 1119. Metro NYOJ 195 飞翔 解题报告

Ural 1146. Maximum Sum NYOJ 104 最大和 解题报告

NYOJ 136 等式 解题报告

poj 1185 炮兵阵地（状态压缩DP）

Ural 1119. Metro NYOJ 195 飞翔解题报告

Ural 1146. Maximum Sum NYOJ 104 最大和解题报告

NYOJ 136 等式解题报告