[Offer收割]编程练习赛4

最新推荐文章于 2022-05-31 19:31:27 发布

yphacker

最新推荐文章于 2022-05-31 19:31:27 发布

阅读量611

点赞数

分类专栏： ======hihoCoder======

本文链接：https://blog.csdn.net/piaocoder/article/details/52173939

版权

======hihoCoder====== 专栏收录该内容

10 篇文章 0 订阅

订阅专栏

满减优惠

题目链接：

http://hihocoder.com/problemset/problem/1353

解题思路：

题目大意：
从数组中选出若干个数，使得这些数的和大于X，并且尽可能的小。
算法思想：
规模很小的背包问题。因此O(2^N)的枚举或者DP都可以解决。

AC代码（枚举）：

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

const int N = 25;
int a[N];

int main(){
    int n,x;
	while(~scanf("%d%d",&n,&x)){
        int sum = 0;
        for(int i = 0; i < n; ++i) {
            scanf("%d",&a[i]);
            sum += a[i];
        }
        if(sum < x) {
            puts("-1");
            return 0;
        }
        int ans = INF;
        for(int i = 1; i < (1<<n); ++i) {
            int tmp = 0;
            for(int j = 0; j < n; ++j) {
                if((i>>j) & 1) {
                    tmp += a[j];
                }
            }
            if(tmp >= x)
                ans = min(ans,tmp);
        }
        printf("%d\n", ans);
	}
	return 0;
}

AC代码（dp）：

#include <bits/stdc++.h>
using namespace std;

const int N = 105;
const int M = 205;
int a[N],dp[N][M];

int main(){
    int n,x;
    while(~scanf("%d%d",&n,&x)){
        int ans = -1;
        for(int i = 1; i <= n; ++i)
            scanf("%d",a + i);
        memset(dp,0,sizeof(dp));
        dp[0][0] = 1;
        for(int i = 1; i <= n; ++i){
            for(int j = 0; j <= x+100; ++j){
                dp[i][j] = dp[i-1][j];
                if(j-a[i] >= 0)
                    dp[i][j]=max(dp[i][j],dp[i-1][j-a[i]]);
            }
        }

        for(int i = x; i <= x+100; ++i){
            if(dp[n][i] == 1){
                ans = i;
                break;
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}

积水的城市

题目链接：

http://hihocoder.com/problemset/problem/1354

解题思路：

有障碍的最短路径问题，对于无权的格子问题，只需要利用BFS探索即可。但由于本题中“路”和“街”的长度可能不同，因此，利用SPFA算法。也就是在BFS的基础上，记录源点到其它每个点的距离，当新探索出的路径长度更小时，更新记录，并将当前状态入栈。当遇到“积水”的路口时，直接丢弃该状态即可表示不能通过本路口。

AC代码：

#include <bits/stdc++.h>
#define INF 0x3f3f3f3f
using namespace std;

const int N = 505;
const int M = 505;
const int dx[] = {-1,0,1,0};
const int dy[] = {0,1,0,-1};

struct node{
    int x,y,d;
    node(int a,int b,int c) : x(a),y(b),d(c){}
    bool operator < (const node &s) const{
        return d > s.d;
    }
};

int n,m;
int A[M];
int B[N];
int vis[N][M];
set<pair<int, int> > dead;

int solve(int x,int y,int p,int q){
    priority_queue<node> pq;
    pq.push(node(x,y,0));
    vis[x][y] = 0;
    while(!pq.empty()){
        node cur = pq.top();
        pq.pop();
        // explore 4 directions
        for(int i = 0; i < 4; ++i) {
            int xx = cur.x + dx[i];
            int yy = cur.y + dy[i];
            // skip invalid coordinates and water crossing
            if(xx <= 0 || yy <= 0 || xx > n || yy > m || dead.find(make_pair(xx, yy)) != dead.end())
                continue;
            int d = dx[i] == 0 ? cur.d + A[min(cur.y, yy)]:cur.d + B[min(cur.x, xx)];
            // skip longer path
            if (vis[xx][yy] <= d)
                continue;
            // skip the destination itself
            if (xx != p || yy != q)
                pq.push(node(xx, yy, d));
            vis[xx][yy] = d;
        }
    }
    return vis[p][q] == INF?-1:vis[p][q];
}

int main(){
    while(~scanf("%d%d",&n,&m)){
        for(int i = 1; i < n; ++i)
            scanf("%d",&B[i]);
        for(int i = 1; i < m; ++i)
            scanf("%d",&A[i]);
        int k;
        scanf("%d",&k);
        for(int i = 0; i < k; ++i){
            int x, y;
            scanf("%d%d",&x,&y);
            dead.insert(make_pair(x, y));
        }
        int Q;
        scanf("%d",&Q);
        for(int i = 0; i < Q; ++i){
            int x,y,p,q;
            scanf("%d%d%d%d",&x,&y,&p,&q);
            memset(vis,INF,sizeof(vis));
            printf("%d\n",solve(x,y,p,q));
        }
    }
    return 0;
}

罚抄一百遍

题目链接：

http://hihocoder.com/problemset/problem/1355

解题思路：

根据题意的描述，可知当抄写的次数足够多时，必须存在循环节，也就是当抄写次数足够多时，必然存在i, j，使得第i次抄写和第j次抄写开始的列数相同。寻找循环节的方法也很简单，只需要用Hash表记录，每次抄写时开始的行数x,列数y即可。
由于题目要求每两个单词之间必须存在一个空格，第二遍抄写的第一个单词与第一遍的最后一个单词之间，也要存在一个空格。所以我们可以把要抄写的字符串前加上一个空格，以方便处理。那么此时，第一遍抄写时开始的行x=1，列y=-1。
当我们利用Hash表找到循环节后，即可以跳过中间重复的模拟过程。
此外，要小心行数x溢出int表示范围。

AC代码：

#include <bits/stdc++.h>
using namespace std;

typedef long long ll;
// copy n times starting at (x, y)
void ncopy(const vector<int> &nums,int n,int m,ll &x,int &y){
    for(int i = 0; i < n; ++i){
        for(int j = 0; j < (int)nums.size(); ++j){
            if(y == m)
                y = 0, ++x;
            ++y;
            if(y+nums[j] > m)
                y = 0, ++x;
            y += nums[j];
        }
    }
}

int main(){
    int n,m;
    scanf("%d%d",&n,&m);
    vector<int> words;
    string str;
    while(cin>>str)
        words.push_back(str.size());

    // record nth copy starting at (x, y) => dict[y] = make_pair(n, x)
    unordered_map<int, pair<int, ll>> dict;//c++ 11里面的
    ll x = 1;
    int y = -1;
    for(int i = 1; i <= n; ++i){
        ncopy(words,1,m,x,y);
        if(dict.find(y) != dict.end()){ // find the repetend
            // fast forward to skip the repetend
            ll remain = (n-i)%(i-dict[y].first);
            // add x by repetend's rows
            x += (n-i)/(i-dict[y].first)*(x-dict[y].second);
            // copy the reset times
            ncopy(words,remain,m,x,y);
            break;
        }
        // record ith copy starting at (x, y)
        dict.emplace(y,make_pair(i,x));
    }
    printf("%lld %d\n",x,y);
    return 0;
}

分隔相同整数

题目链接：

http://hihocoder.com/problemset/problem/1356

解题思路：

将一个由长度为n(n>1)同一字母组成的字符串分隔开，显然需要n-1个其它字符。由此，我们可以统计，输入字符串的每个数字出现

的次数Bi，我们可以按照如下规则排列数字：

若出现最多的数字x的次数为Bx，则分隔x至少需要Bx-1个数字，若Bx + Bx - 1 < N，说明还有充足的字符可以分隔x，故输出与前次

输出不同的最小数字即可;否则，说明此时必须输出x，因为，分隔x的字符即将不足。此时，若x与前次输出数字相同，则无解。

因此，我们可以利用Hash表，统计各数字出现的次数，将利用二叉查找树，得到次数最多的数字。此处，不使用大根堆的原因是，

当输出的数字不是次数最多的数字，即输出的数字不是大根堆的堆顶元素，此时，更新相应元素的次数后，需要调整堆，以满足大

根堆的性质，这个操作比较麻烦。

AC代码：

#include <bits/stdc++.h>
using namespace std;

bool solve(vector<int> &s){
    map<int,int> dict;
    map<int,int>::iterator it;
    // count every number's times
    for(int i = 0; i < (int)s.size(); ++i)
        ++dict[s[i]];
    set<pair<int, int> > heap;
    // use black-red tree simulate heap
    for(it = dict.begin(); it != dict.end(); ++it)
        heap.insert(make_pair(it->second, it->first));
    vector<int>::size_type len = s.size(), id = 0;
    int last = -1;
    while(len){
        it = dict.find(heap.rbegin()->second);
        if(len/2 < it->second){ // rule 2
            if(last == it->first) // fail to rearrange
                return false;
        }else{ // rule 1
            it = dict.begin();
            if(it->first == last)
                ++it;
            assert(it != dict.end());
        }
        // output a number
        s[id++] = it->first;
        // update heap
        heap.erase(make_pair(it->second, it->first));
        it->second -= 1;
        if(it->second == 0)
            dict.erase(it);
        else
            heap.insert(make_pair(it->second, it->first));
        last = s[id-1];
        --len;
    }
    return true;
}

int main(void){
    int n;
    while(~scanf("%d",&n)){
        vector<int> nums(n);
        for(int i = 0; i < n; ++i)
            scanf("%d",&nums[i]);
        if(!solve(nums))
            puts("-1");
        else{
            printf("%d",nums[0]);
            for(int i = 1; i < n; ++i)
                printf(" %d",nums[i]);
            printf("\n");
        }
    }
    return 0;
}

参考于buptlxb聚聚的解析。