LeetCode948-令牌放置

问题：令牌放置

你的初始能量为 P，初始分数为 0，只有一包令牌。

令牌的值为 token[i]，每个令牌最多只能使用一次，可能的两种使用方法如下：

• 如果你至少有 token[i] 点能量，可以将令牌置为正面朝上，失去 token[i] 点能量，并得到 1 分。
• 如果我们至少有 1 分，可以将令牌置为反面朝上，获得 token[i] 点能量，并失去 1 分。

在使用任意数量的令牌后，返回我们可以得到的最大分数。

示例 1：

输入：tokens = [100], P = 50
输出：0

示例 2：

输入：tokens = [100,200], P = 150
输出：1

示例 3：

输入：tokens = [100,200,300,400], P = 200
输出：2

提示：

1. tokens.length <= 1000
2. 0 <= tokens[i] < 10000
3. 0 <= P < 10000

链接：https://leetcode-cn.com/contest/weekly-contest-112/problems/bag-of-tokens/

分析：

一个游戏，有初始能量，可以选择拿能量换分数，也可以选择拿分数换能量，最终要尽可能多的分数。

那么完全可以将token排序，小的token[i]消耗能量换分数，大的token[i]消耗分数换能量

0.初始分数0，如果初始能量都不能换到最小的token，则无法启动，最终结果0分

1.如果是最后一个，没必要拿能量换分数

2.尽可能的将能量换分数，直到不能交换位置，然后拿分数去换大的token[i]能量

AC Code：

class Solution {
public:
    int bagOfTokensScore(vector<int>& tokens, int P) {
        int ret = ;
        sort(tokens.begin(), tokens.end());
        if (tokens.size()== || P < tokens[])  //没有token或者无法启动
        {
            return ;
        }
        //最小值token用来换分，最大值token用来换power,最后一个动作如果是换power，放弃
        //优先换分数，换不了了用分数换power
        int leftindex = ;
        int rightindex = tokens.size()-;
        while (rightindex>=)
        {
            if (rightindex < leftindex)
            {
                break;
            }
            //while (P >= tokens[leftindex] && leftindex<=rightindex)
            while (leftindex < tokens.size() && P >= tokens[leftindex] )
            {
                P -= tokens[leftindex];
                leftindex++;
                ret++;
            }
            if (rightindex <= leftindex)
            {
                break;
            }
            P += tokens[rightindex];
            rightindex--;
            ret--;
        }

        return ret;
    }
};

其他：

1.第一code

typedef long long ll;
typedef vector<int> VI;
typedef pair<int,int> PII;

#define REP(i,s,t) for(int i=(s);i<(t);i++)
#define FILL(x,v) memset(x,v,sizeof(x))

const int INF = (int)1E9;
#define MAXN 100005

class Solution {
public:
  int bagOfTokensScore(vector<int>& tokens, int P) {
    if (tokens.size() == ) {
      return P >= tokens[] ?  : ;
    }
    sort(tokens.begin(), tokens.end());
    int n = tokens.size(), ans = ;
    REP(i,,n/) {
      int p = P, t = ;
      REP(j,,i) {
        if (p < tokens[j]) break;
        p -= tokens[j];
        p += tokens[n -  - j];
        t++;
      }
      int sol = ;
      REP(j,t,n-t) {
        if (p >= tokens[j]) {
          p -= tokens[j];
          sol++;
        } else break;
      }
      ans = max(ans, sol);
    }
    return ans;
  }
};