zoukankan      html  css  js  c++  java
  • bzoj2310 ParkII

    2310: ParkII

    Time Limit: 20 Sec  Memory Limit: 128 MB
    Submit: 273  Solved: 104
    [Submit][Status][Discuss]

    Description

    Hnoi2007-Day1有一道题目 Park:给你一个 m * n 的矩阵,每个矩阵内有个
    权值V(i,j) (可能为负数),要求找一条回路,使得每个点最多经过一次,并且经过
    的点权值之和最大,想必大家印象深刻吧. 
    无聊的小 C 同学把这个问题稍微改了一下:要求找一条路径,使得每个点
    最多经过一次,并且点权值之和最大,如果你跟小 C 一样无聊,就麻烦做一下
    这个题目吧.

    Input

    第一行 m, n,接下来 m行每行 n 个数即
    V( i,j)

    Output

    一个整数表示路径的最大权值之和.

    Sample Input

    2 3
    1 -2 1
    1 1 1

    Sample Output

    5
    【数据范围】
    30%的数据,n≤6.
    100%的数据,m<=100,n≤8.
    注意:路径上有可能只有一个点.
    分析:在bzoj1187的基础上将回路改成了路径. 那么需要多定义一种插头:独立插头.  分16种情况讨论......我参考了:传送门的题解.
       怎么样不遗漏地讨论这些情况呢?分为三类:1.下插头和右插头都不存在 2.下插头和右插头有一个存在 3.下插头和右插头都存在.
    对于回路的讨论在这道题里都是对的,只是要新增对独立插头的讨论.
       重点考虑独立插头的产生与何时统计答案.独立插头在什么情况下可能产生呢?
       1.在下插头和右插头都不存在的情况下,那么下插头和右插头任意一个都可以当作独立插头.
       2.只存在一个插头的情况下,并且这个插头不是独立插头.可以不延伸这个插头,将它作为路径的一端,那么与它匹配的另一个插头就变成了独立插头.
       3.如果两个插头都存在,并且一个插头是独立插头. 把它们连接起来后,与这个不是独立插头的插头匹配的插头就变成了独立插头,因为没有插头与它匹配了.
       那么什么时候统计答案?
       1.下插头和右插头只有一个插头并且这个插头是独立插头的时候. 对于这个插头,它可以向两个方向延伸,每一次延伸实际上就是更新路径.那么就可以更新答案, 为了确保形成的确实是一条路径,在更新答案前要先判断状态是否为0.
       2.两个独立插头合并的时候.  可以看作是两个独立插头延伸碰到一起了. 也是要先判断一下状态是否为0.
       可以看出,什么时候统计答案取决于什么时候可能形成一条路径.
       要想做出这道题一定要理解清楚独立插头的概念,它是没有与之相匹配的插头.不允许去查找相匹配的插头.
       一个注意点:排除形成回路的情况!
    #include <cstdio>
    #include <cstring>
    #include <iostream>
    #include <algorithm>
    
    using namespace std;
    
    const int inf = 0x7ffffff,maxn = 30010;
    int n,m,a[110][110],ans = -inf,pow[10],now,pre;
    
    struct node
    {
        int head[maxn],nextt[maxn],sum[maxn],sta[maxn],tot;
        void clear()
        {
            memset(head,-1,sizeof(head));
            tot = 0;
            memset(sum,128/3,sizeof(sum));
            memset(sta,0,sizeof(sta));
        }
        void push(int x,int v)
        {
            int hashh = x % 10001;
            for (int i = head[hashh]; i >= 0; i = nextt[i])
            {
                if (sta[i] == x)
                {
                    sum[i] = max(sum[i],v);
                    return;
                }
            }
            sum[tot] = v;
            sta[tot] = x;
            nextt[tot] = head[hashh];
            head[hashh] = tot++;
        }
    } f[2];
    
    int turnleft(int x,int pos)
    {
        return x << pow[pos];
    }
    
    int get(int x,int pos)
    {
        return (x >> pow[pos]) & 3;
    }
    
    int del(int x,int i,int j)
    {
        return x & (~(3 << pow[i])) & (~(3 << pow[j]));
    }
    
    int findr(int x,int pos)
    {
        int cnt = 1;
        for (int i = pos + 1; i <= m; i++)
        {
            int temp = get(x,i);
            if (temp == 1)
                cnt++;
            else if (temp == 2)
                cnt--;
            if (cnt == 0)
                return i;
        }
    }
    
    int findl(int x,int pos)
    {
        int cnt = 1;
        for (int i = pos - 1; i >= 0; i--)
        {
            int temp = get(x,i);
            if (temp == 2)
                cnt++;
            else if (temp == 1)
                cnt--;
            if (cnt == 0)
                return i;
        }
    }
    
    void solve2(int x,int y,int k)
    {
        int p = get(f[pre].sta[k],y - 1);
        int q = get(f[pre].sta[k],y);
        int staa = del(f[pre].sta[k],y - 1,y);
        int v = f[pre].sum[k];
        if (staa > (1 << pow[m + 1]))
            return;
        if (!p && !q)
        {
            f[now].push(staa,v);
            f[now].push(staa | turnleft(1,y - 1) | turnleft(2,y),v + a[x][y]);
            f[now].push(staa | turnleft(3,y - 1),v + a[x][y]);
            f[now].push(staa | turnleft(3,y),v + a[x][y]);
        }
        else if (!p)
        {
            int temp = p + q;
            if (q != 3)
            {
                f[now].push(staa | turnleft(temp,y),v + a[x][y]);
                f[now].push(staa | turnleft(temp,y - 1),v + a[x][y]);
                if (q == 1)
                    f[now].push(staa ^ turnleft(temp,findr(staa,y)),v + a[x][y]);
                else
                    f[now].push(staa ^ turnleft(temp,findl(staa,y)),v + a[x][y]);
            }
            else
            {
                f[now].push(staa | turnleft(temp,y),v + a[x][y]);
                f[now].push(staa | turnleft(temp,y - 1),v + a[x][y]);
                if (staa == 0)
                    ans = max(ans,v + a[x][y]);
            }
        }
        else if (!q)
        {
            int temp = p + q;
            if (p != 3)
            {
                f[now].push(staa | turnleft(temp,y - 1),v + a[x][y]);
                f[now].push(staa | turnleft(temp,y),v + a[x][y]);
                if (p == 1)
                    f[now].push(staa ^ turnleft(temp,findr(staa,y - 1)),v + a[x][y]);
                else
                    f[now].push(staa ^ turnleft(temp,findl(staa,y - 1)),v + a[x][y]);
            }
            else
            {
                f[now].push(staa | turnleft(temp,y - 1),v + a[x][y]);
                f[now].push(staa | turnleft(temp,y),v + a[x][y]);
                if (staa == 0)
                    ans = max(ans,v + a[x][y]);
            }
        }
        else if (p == 1 && q == 1)
            f[now].push(staa ^ turnleft(3,findr(staa,y)),v + a[x][y]);
        else if (p == 2 && q == 2)
            f[now].push(staa ^ turnleft(3,findl(staa,y - 1)),v + a[x][y]);
        else if (p == 2 && q == 1)
            f[now].push(staa,v + a[x][y]);
        else if (p == 3 && q == 1)
            f[now].push(staa ^ turnleft(1,findr(staa,y)),v + a[x][y]);
        else if (p == 3 && q == 2)
            f[now].push(staa ^ turnleft(2,findl(staa,y)),v + a[x][y]);
        else if (p == 1 && q == 3)
            f[now].push(staa ^ turnleft(1,findr(staa,y - 1)),v + a[x][y]);
        else if (p == 2 && q == 3)
            f[now].push(staa ^ turnleft(2,findl(staa,y - 1)),v + a[x][y]);
        else if (p == 3 && q == 3)
            if (staa == 0)
                ans = max(ans,v + a[x][y]);
    }
    
    void solve()
    {
        now = 0,pre = 1;
        f[0].clear();
        f[0].push(0,0);
        for (int i = 1; i <= n; i++)
        {
            pre = now;
            now ^= 1;
            f[now].clear();
            for (int k = 0; k < f[pre].tot; k++)
                f[now].push(turnleft(f[pre].sta[k],1),f[pre].sum[k]);
            for (int j = 1; j <= m; j++)
            {
                pre = now;
                now ^= 1;
                f[now].clear();
                for (int k = 0; k < f[pre].tot; k++)
                    solve2(i,j,k);
            }
        }
    }
    
    int main()
    {
        for (int i = 1; i < 10; i++)
            pow[i] = i * 2;
        scanf("%d%d",&n,&m);
        for (int i = 1; i <= n; i++)
            for (int j = 1; j <= m; j++)
            {
                scanf("%d",&a[i][j]);
                ans = max(ans,a[i][j]);
            }
        solve();
        printf("%d
    ",ans);
    
        return 0;
    }
     
  • 相关阅读:
    SqlServer 利用临时表批量添加&&修改数据库表中的数据
    有关Linux的实时性
    烟囱式到SOA再到微服务
    消费金融前世今生
    其它 一加7t禁止系统更新
    电商 相关底层知识
    CRMEB 基础 列表拖动排序2
    CRMEB 基础 列表拖动排序1
    前端 table排序
    MacBook 关闭访客登陆
  • 原文地址:https://www.cnblogs.com/zbtrs/p/8459265.html
Copyright © 2011-2022 走看看