2016.5.25（2）

最新推荐文章于 2023-10-24 08:00:00 发布

pku_15120

最新推荐文章于 2023-10-24 08:00:00 发布

阅读量228

点赞数

分类专栏：第二学期学习日志算法

本文链接：https://blog.csdn.net/pku_15120/article/details/51501726

版权

算法同时被 2 个专栏收录

15 篇文章 0 订阅

订阅专栏

第二学期学习日志

14 篇文章 0 订阅

订阅专栏

2.最大子矩阵

题目链接：http://noi.openjudge.cn/ch0206/1768/

心得：将子矩阵的二维问题转化为求一个数组中最大子段和的一维问题。

核心状态转移方程： dp[i] = max(dp[i - 1] + a[i], a[i]) dp[i]表示从数组a[0]到a[i]的最大子段和，dp[i]的当前值只有两种情况，(1) 最大子段一直连续到a[i] (2) 以a[i]为起点的子段,还有一种情况，那就是最大字段没有包含a[i]，如果没有包含a[i]的话，那么在算dp[i]之前的时候我们已经算出来了，注意我们只是算到位置为j的地方，所以最大子断在a[j]后面的情况我们可以暂时不考虑。

解决一维问题后，二维的子矩阵就可以解决了，把子矩阵对应两行之间每列的值加起来即可。

#include <iostream>
#include <cstdio>

using namespace std;

int a[101][101], b[101];
//求最大子段和
int dp(int b[], int n)
{
    int i = 0;
    int c = 0;
    int max = -128;
    for (int i = 0; i < n; ++i)
    {
        if (c <= 0)
            c = b[i];
        else
            c += b[i];
        //不用担心最大子段和不包括b[i]的情况，因为之前已经计算过了
        if (c > max)
            max = c;
    }
    return max;
}
int main()
{
    int n, max = -128;
    scanf("%d", &n);
    for (int i = 0; i < n; ++i)
        for (int j = 0; j < n; ++j)
            scanf("%d", &a[i][j]);
    //i, j用来枚举所有行的组合
    for (int i = 0; i < n; ++i)
        for (int j = i; j < n; ++j)
        {
            memset(b, 0, sizeof(b));
            //把两行之间的每列总和计算出来
            for (int t = 0; t < n; ++t)
                for (int k = i; k <= j; ++k)
                {
                    b[t] += a[k][t];
                    int sum = dp(b, n);
                    if (sum > max)
                        max = sum;
                }
        }
    printf("%d\n", max);
    return 0;
}

3.灌溉草场

题目链接：http://poj.org/problem?id=2373

本题只用作欣赏...根据课件自己写了遍代码也没啥感觉..

比较有价值的第一个地方在通过一个数组来表示每个点是否有牛存在

memset(cowThere, 0, sizeof(cowThere));
    for (int i = 0; i < N; ++i)
    {
        cin >> S >> E;
        cowThere[S + 1]++;
        cowThere[E]--;
    }
    int inCows = 0;
    for (int i = 0; i <= L; i++)
    {
        F[i] = inf;
        inCows += cowThere[i];
        cowThere[i] = (inCows > 0);
    }

通过priority_queue来降低时间复杂度也是一种不错的思路，就是还不太会运用...

然后就是对于题目的分析，确实挺复杂的，直接贴代码吧

#include <iostream>
#include <cstring>
#include <queue>
using namespace std;
const int INFINITE = 0x3f3f3f3f;
const int MAXL = 1000010;
const int MAXN = 1010;
int F[MAXL]; // F[L]就是答案
int cowThere[MAXL]; //cowThere[i]为1表示点i有奶牛
int N, L, A, B;
class Fx
{
public:
    int x; 
    int f;
    bool operator<(const Fx & a) const { return f > a.f; }
    Fx(int xx = 0, int ff = 0) :x(xx), f(ff) { }
};// 在优先队列里，f值越小的越优先
priority_queue<Fx> qFx;
int main()
{
    cin >> N >> L;
    cin >> A >> B;
    A <<= 1; B <<= 1; //A,B的定义变为覆盖的直径
    memset(cowThere, 0, sizeof(cowThere));
    //以下两个循很聪明的让每个有奶牛的位置赋值，且复杂度为O(n)
    for (int i = 0; i < N; ++i) 
    {
        int s, e;
        cin >> s >> e;
        ++cowThere[s + 1]; //从s+1起进入一个奶牛区
        --cowThere[e]; //从e起退出一个奶牛区
    }
    int inCows = 0; //表示当前点位于多少头奶牛的活动范围之内
    for (int i = 0; i <= L; i++) 
    { //算出每个点是否有奶牛
        F[i] = INFINITE;
        inCows += cowThere[i];
        cowThere[i] = inCows > 0;
    }
    for (int i = A; i <= B; i += 2) //初始化队列
        if (!cowThere[i]) 
        {
            F[i] = 1;
            if (i <= B + 2 - A) //在求F[i]的时候，要确保队列里的点x，x <= i - A
                qFx.push(Fx(i, 1));
        }
    for (int i = B + 2; i <= L; i += 2) 
    {
        if (!cowThere[i]) 
        {
            Fx fx;
            while (!qFx.empty()) 
            {
                fx = qFx.top();
                if (fx.x < i - B)
                    qFx.pop();
                else
                    break;
            }
            if (!qFx.empty())
                F[i] = fx.f + 1;
        }
        if (F[i - A + 2] != INFINITE)
        {//队列中增加一个+1可达下个点的点
            qFx.push(Fx(i - A + 2, F[i - A + 2]));
        }
    }
    if (F[L] == INFINITE)
        cout << -1 << endl;
    else
        cout << F[L] << endl;
    return 0;
}