POJ 1275/HDU 1529 Cashier Employment (差分约束)

POJ链接
HDU链接

题意:一个商店,告诉你一天每个小时里至少需要的人数,以及来应聘的人数的工作的起始时间,固定工作8小时,求最少应该雇佣的人数。

思路:设 s[i] 表示在前 i 小时,总开始工作的人数,所以, i>=8时, 有 s[i] - s[i-8] >= i时刻需要的人数,
i<8 时, 有 s[i]+s[24]-s[i+16]>=i时刻需要的人数 。 同时,对于相邻时间会有 0<=s[i] - s[i-1]<=i时刻开始工作的人数。在这里会发现 s[24] 就是我们要求的答案,但就这样的话还是求不出,所以枚举s[24];

想法:难点在建立不等式,即建图。(大佬厉害)

#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
const int maxn = 50;
const int inf = 0x3f3f3f3f;
using namespace std;
struct note{
    int to, w;
    note(int to1, int w1){
        to = to1, w = w1;
    }
};
vector <note> maps[maxn];
int need[maxn], work[maxn], ans;
//need[i] i时刻需要的人数
//work[i] i时刻开始工作的人数


void init(){//要枚举答案, 所以每次要初始化,并建图
    for(int i=0; i<=24; i++)
        maps[i].clear();
    for(int i=1; i<=24; i++){
        maps[i-1].push_back(note(i, 0));	// s[i] - s[i-1] >= 0
        maps[i].push_back(note(i-1, -work[i]));
        //s[i] - s[i-1] <= work[i]  --->  s[i-1] - s[i] >= -work[i]
        if(i>=8)
            maps[i-8].push_back(note(i, need[i]));	//s[i] - s[i-8] >= need[i]
        else
            maps[16+i].push_back(note(i, need[i]-ans)); //s[i] - s[i+16] >= need[i]-ans
    }
    maps[0].push_back(note(24, ans));	//s[24]-s[0]>=ans  (容易忘记)
}

bool spfa(){
    int dis[maxn], cnt[maxn];
    //图有可能回出现负环, cnt[i] 记录 i 点入队列的次数
    bool vis[maxn];
    for(int i=0; i<=24; i++)
        dis[i] = -inf, vis[i] = false, cnt[i] = 1;
    dis[0] = 0, vis[0] = true, cnt[0] = 1;
    queue <int> q;
    q.push(0);
    while(!q.empty()){
        int u = q.front();
        q.pop();
        vis[u] = false;
        for(int i=0, len = maps[u].size(); i<len; i++){
            int v = maps[u][i].to, w = maps[u][i].w;
            if(dis[v] < dis[u] + w){
                dis[v] = dis[u] + w;
                if(!vis[v]){
                    cnt[v]++;
                    if(cnt[v] > 24)
                        return false; //存在负环,无解
                    vis[v] = true;
                    q.push(v);
                }
            }
        }
    }
    if(dis[24] == ans)
        return true;
    return false;
}

int main()
{
    int t;
    scanf("%d", &t);
    while(t--){
        for(int i=1; i<=24; i++){
            scanf("%d", &need[i]);
        }
        int n;
        scanf("%d", &n);
        for(int i=1; i<=n; i++){
            int j;
            scanf("%d", &j);
            work[j+1]++;
        }
        for(ans=0; ans<=n; ans++){ //枚举
            init();
            if(spfa()){
                break;
            }
        }
        if(ans > n)
            printf("No Solution\n");
        else
            printf("%d\n", ans);
    }
    return 0;
}

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
在信号处理领域,DOA(Direction of Arrival)估计是一项关键技术,主要用于确定多个信号源到达接收阵列的方向。本文将详细探讨三种ESPRIT(Estimation of Signal Parameters via Rotational Invariance Techniques)算法在DOA估计中的实现,以及它们在MATLAB环境中的具体应用。 ESPRIT算法是由Paul Kailath等人于1986年提出的,其核心思想是利用阵列数据的旋转不变性来估计信号源的角度。这种算法相比传统的 MUSIC(Multiple Signal Classification)算法具有较低的计算复杂度,且无需进行特征值分解,因此在实际应用中颇具优势。 1. 普通ESPRIT算法 普通ESPRIT算法分为两个主要步骤:构造等效旋转不变系统和估计角度。通过空间平移(如延时)构建两个子阵列,使得它们之间的关系具有旋转不变性。然后,通过对子阵列数据进行最小二乘拟合,可以得到信号源的角频率估计,进一步转换为DOA估计。 2. 常规ESPRIT算法实现 在描述中提到的`common_esprit_method1.m`和`common_esprit_method2.m`是两种不同的普通ESPRIT算法实现。它们可能在实现细节上略有差异,比如选择子阵列的方式、参数估计的策略等。MATLAB代码通常会包含预处理步骤(如数据归一化)、子阵列构造、旋转不变性矩阵的建立、最小二乘估计等部分。通过运行这两个文件,可以比较它们在估计精度和计算效率上的异同。 3. TLS_ESPRIT算法 TLS(Total Least Squares)ESPRIT是对普通ESPRIT的优化,它考虑了数据噪声的影响,提高了估计的稳健性。在TLS_ESPRIT算法中,不假设数据噪声是高斯白噪声,而是采用总最小二乘准则来拟合数据。这使得算法在噪声环境下表现更优。`TLS_esprit.m`文件应该包含了TLS_ESPRIT算法的完整实现,包括TLS估计的步骤和旋转不变性矩阵的改进处理。 在实际应用中,选择合适的ESPRIT变体取决于系统条件,例如噪声水平、信号质量以及计算资源。通过MATLAB实现,研究者和工程师可以方便地比较不同算法的效果,并根据需要进行调整和优化。同时,这些代码也为教学和学习DOA估计提供了一个直观的平台,有助于深入理解ESPRIT算法的工作原理。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值