leetcode周赛 243

A：水题。

https://leetcode-cn.com/problems/check-if-word-equals-summation-of-two-words/

class Solution {
public:
    int tans(string s){
        int res=0;
        for(int i=0;i<s.size();i++){
            res=res*10+s[i]-'a';
        }
        return res;
    }
    bool isSumEqual(string a, string b, string tar) {
        if(tans(a)+tans(b)==tans(tar)) return true;
        return false;
    }
};

B：给定一个数字字符串（可正可负）和一个在1~9之间的数x，问将x插入后，最大值为多少。

贪心，如果是正数，就希望高位尽可能大，否则就是高位尽可能小。

假设某正数为abcdef，其中a>b,x>b，那么最好方案必然是axbcdef。（可以证明将x放在其他任何地方，都比这要小）

负数同理可证。

class Solution {
public:
    string maxValue(string n, int x) {
        string res="";
        int l=0,r=n.size()-1;
        if(n[0]=='-'){
            l+=1;    
        }
        if(n[0]!='-'){
            for(int i=l;i<=r;i++){
                if(n[i]-'0'<x&&x!=-1)
                {
                    res+=x+'0';
                    x=-1;
                }
                res+=n[i];
            }
            if(x!=-1)
                res+=x+'0';
        }else if(n[0]=='-'){
            res+='-';
            for(int i=l;i<=r;i++){
                if(n[i]-'0'>x&&x!=-1)
                {
                    res+=x+'0';
                    x=-1;
                }
                res+=n[i];
            }
            if(x!=-1)
                res+=x+'0';
        }
        return res;
    }
};

C：https://leetcode-cn.com/problems/process-tasks-using-servers/

可以将服务器分为空闲和忙碌两种状态。

　　空闲服务器有的操作：找到权值最小的服务器，删除（进入工作状态），添加（工作完成），故可以用堆来维护

　　忙碌服务器有的操作：找到最先完成的服务器，删除（完成任务），添加（进入工作状态），同样可以用堆来维护。

typedef long long LL;
class Solution {
public:
    struct node1{//空闲服务器堆中的点
        LL id,w,t;
        bool operator<(const node1 tmp) const {
            if(w==tmp.w) return id<tmp.id;
            return w<tmp.w;
        }
        bool operator>(const node1 tmp) const {
            if(w==tmp.w) return id>tmp.id;
            return w>tmp.w;
        }
    };
    struct node2{//忙碌服务器堆中的点
        LL id,w,t;
        bool operator<(const node2 tmp) const {
            if(t!=tmp.t) return t<tmp.t;
            if(w!=tmp.w) return w<tmp.w;
            return id<tmp.id;
        }
        bool operator>(const node2 tmp) const {
            if(t!=tmp.t) return t>tmp.t;
            if(w!=tmp.w) return w>tmp.w;
            return id>tmp.id;
        }
    };
    priority_queue<node1,vector<node1>,greater<node1>> free;
    priority_queue<node2,vector<node2>,greater<node2>> busy;
    vector<int> ans;
    vector<int> assignTasks(vector<int>& se, vector<int>& ta) {
        for(int i=0;i<se.size();i++) free.push({i,se[i],0});
        for(int i=0;i<ta.size();i++){
            while(busy.size()&&busy.top().t<=i){
                auto tmp=busy.top();
                busy.pop();
                free.push({tmp.id , tmp.w , tmp.t});
            }
            if(free.size()){
                auto tmp=free.top();
                free.pop();
                ans.push_back(tmp.id);
                busy.push({tmp.id , tmp.w , i+ta[i]});
            }else{
                auto tmp=busy.top();
                busy.pop();
                ans.push_back(tmp.id);
                busy.push({tmp.id , tmp.w , tmp.t+ta[i]});
            }
        }
        return ans;
    }
};

D：https://leetcode-cn.com/problems/minimum-skips-to-arrive-at-meeting-on-time/

模型类似于上一次周赛，必须在整点上车。

可以将等待时间归到前一段，即f[i][j]表示经过i段路，操作次数为j的最小花费时间。

存在精度问题(因为需要对double上取整)。

const int N=1010,INF=1e9;
const double eps=1e-8;
double f[N][N];
class Solution {
public:
    int minSkips(vector<int>& dist, int speed, int hoursBefore) {
        int n=dist.size();
        for(int i=1;i<=n;i++){
            double t=(double)dist[i-1]/speed;
            for(int j=0;j<=i;j++){
                f[i][j]=INF;
                if(j<=i-1) f[i][j]=min(f[i][j],ceil(f[i-1][j]+t -eps ));
                if(j-1>=0) f[i][j]=min(f[i][j],f[i-1][j-1]+t);//j-1<=i-1必然成立
            }
        }
        for(int i=0;i<=n;i++){
            if(f[n][i]<=hoursBefore){
                return i;
            }
        }
        return -1;
    }
};