8015. 距离原点最远的点
给你一个长度为 n 的字符串 moves ，该字符串仅由字符 'L'、'R' 和 '_' 组成。字符串表示你在一条原点为 0 的数轴上的若干次移动。
你的初始位置就在原点（0），第 i 次移动过程中，你可以根据对应字符选择移动方向：
如果 moves[i] = 'L' 或 moves[i] = '_' ，可以选择向左移动一个单位距离
如果 moves[i] = 'R' 或 moves[i] = '_' ，可以选择向右移动一个单位距离
移动 n 次之后，请你找出可以到达的距离原点 最远 的点，并返回 从原点到这一点的距离 。
示例 1：
输入：moves = "L_RL__R"
输出：3
解释：可以到达的距离原点 0 最远的点是 -3 ，移动的序列为 "LLRLLLR" 。
示例 2：
输入：moves = "_R__LL_"
输出：5
解释：可以到达的距离原点 0 最远的点是 -5 ，移动的序列为 "LRLLLLL" 。
示例 3：
输入：moves = "_______"
输出：7
解释：可以到达的距离原点 0 最远的点是 7 ，移动的序列为 "RRRRRRR" 。
提示：
1 <= moves.length == n <= 50
moves 仅由字符 'L'、'R' 和 '_' 组成解答：直接遍历，然后取最大值
class Solution {
public int furthestDistanceFromOrigin(String moves) {
int l=0,r=0,count=0;
int n=moves.length();
for(char c:moves.toCharArray()){
if(c=='L')l++;
else if(c=='R')r++;
else count++;
}
return Math.max(l+count-r,r+count-l);
}
}8022. 找出美丽数组的最小和
给你两个正整数：n 和 target 。
如果数组 nums 满足下述条件，则称其为 美丽数组 。
nums.length == n.
nums 由两两互不相同的正整数组成。
在范围 [0, n-1] 内，不存在 两个 不同 下标 i 和 j ，使得 nums[i] + nums[j] == target 。
返回符合条件的美丽数组所可能具备的 最小 和。
示例 1：
输入：n = 2, target = 3
输出：4
解释：nums = [1,3] 是美丽数组。
- nums 的长度为 n = 2 。
- nums 由两两互不相同的正整数组成。
- 不存在两个不同下标 i 和 j ，使得 nums[i] + nums[j] == 3 。
可以证明 4 是符合条件的美丽数组所可能具备的最小和。
示例 2：
输入：n = 3, target = 3
输出：8
解释：
nums = [1,3,4] 是美丽数组。
- nums 的长度为 n = 3 。
- nums 由两两互不相同的正整数组成。
- 不存在两个不同下标 i 和 j ，使得 nums[i] + nums[j] == 3 。
可以证明 8 是符合条件的美丽数组所可能具备的最小和。
示例 3：
输入：n = 1, target = 1
输出：1
解释：nums = [1] 是美丽数组。
提示：
1 <= n <= 10^5
1 <= target <= 10^5解答：使用哈希表添加元素，如果target-i不在哈希表中，就添加元素，直至哈希表长度等于n结束循环
class Solution {
public long minimumPossibleSum(int n, int target) {
long res=0;
int i=0;
Set<Integer> set=new HashSet<>();
while(set.size()<n){
i++;
if(!set.contains(target-i)){
res+=i;
set.add(i);
}
}
return res;
}
}2835. 使子序列的和等于目标的最少操作次数
给你一个下标从 0 开始的数组 nums ，它包含 非负 整数，且全部为 2 的幂，同时给你一个整数 target 。
一次操作中，你必须对数组做以下修改：
选择数组中一个元素 nums[i] ，满足 nums[i] > 1 。
将 nums[i] 从数组中删除。
在 nums 的 末尾 添加 两个 数，值都为 nums[i] / 2 。
你的目标是让 nums 的一个 子序列 的元素和等于 target ，请你返回达成这一目标的 最少操作次数 。如果无法得到这样的子序列，请你返回 -1 。
数组中一个 子序列 是通过删除原数组中一些元素，并且不改变剩余元素顺序得到的剩余数组。
示例 1：
输入：nums = [1,2,8], target = 7
输出：1
解释：第一次操作中，我们选择元素 nums[2] 。数组变为 nums = [1,2,4,4] 。
这时候，nums 包含子序列 [1,2,4] ，和为 7 。
无法通过更少的操作得到和为 7 的子序列。
示例 2：
输入：nums = [1,32,1,2], target = 12
输出：2
解释：第一次操作中，我们选择元素 nums[1] 。数组变为 nums = [1,1,2,16,16] 。
第二次操作中，我们选择元素 nums[3] 。数组变为 nums = [1,1,2,16,8,8] 。
这时候，nums 包含子序列 [1,1,2,8] ，和为 12 。
无法通过更少的操作得到和为 12 的子序列。
示例 3：
输入：nums = [1,32,1], target = 35
输出：-1
解释：无法得到和为 35 的子序列。
提示：
1 <= nums.length <= 1000
1 <= nums[i] <= 2^30
nums 只包含非负整数，且均为 2 的幂。
1 <= target < 2^31解答：从低位到高位依次遍历，
class Solution {
public int minOperations(List<Integer> nums, int target) {
long s = 0;
var cnt = new long[31];
for (int x : nums) {
s += x;
cnt[Integer.numberOfTrailingZeros(x)]++;
}
if (s < target)
return -1;
int ans = 0, i = 0;
s = 0;
while ((1L << i) <= target) {
s += cnt[i] << i;
int mask = (int) ((1L << ++i) - 1);
if (s >= (target & mask))
continue;
ans++; // 一定要找更大的数操作
for (; cnt[i] == 0; i++)
ans++; // 还没找到，继续找更大的数
}
return ans;
}
}
