只出现一次的数字
给定一个非空整数数组,除了某个元素只出现一次以外,其余每个元素均出现了三次。找出那个只出现了一次的元素。
说明:你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗?
示例 1:输入: [2,2,3,2]输出: 3
示例 2:输入: [0,1,0,1,0,1,99]输出: 99
class Solution {
public:
int singleNumber(vector<int>& nums) {
int a = 0, b = 0;
for (auto x : nums) {
a = (a ^ x) & ~b;
b = (b ^ x) & ~a;
}
return a;
}
};
/*x第一次出现后,a = (a ^ x) & ~b的结果为 a = x,
b = (b ^ x) & ~a的结果为此时因为a = x了,所以b = 0。
x第二次出现:a = (a ^ x) & ~b, a = (x ^ x) & ~0, a = 0;
b = (b ^ x) & ~a 化简, b = (0 ^ x) & ~0 ,b = x;
x第三次出现:a = (a ^ x) & ~b, a = (0 ^ x) & ~x ,a = 0;
b = (b ^ x) & ~a 化简, b = (x ^ x) & ~0 , b = 0;
所以出现三次同一个数,a和b最终都变回了0.*/
如果能设计一个状态转换电路,使得一个数出现3次时能自动抵消为0,最后剩下的就是只出现1次的数。
开始设计:一个二进制位只能表示0或者1。也就是天生可以记录一个数出现了一次还是两次。
- x ^ 0 = x;
- x ^ x = 0;
要记录出现3次,需要两个二进制位。那么上面单独的x
就不行了。我们需要两个变量,每个变量取一位:
- ab ^ 00 = ab;
- ab ^ ab = 00;
这里,a
、b
都是32位的变量。我们使用a
的第k
位与b
的第k
位组合起来的两位二进制,表示当前位出现了几次。也就是,一个8
位的二进制x
就变成了16
位来表示。
-
x = x[7] x[6] x[5] x[4] x[3] x[2] x[1] x[0]
-
x = (a[7]b[7]) (a[6]b[6]) ... (a[1]b[1]) (a[0]b[0])
它是一个逻辑电路,a
、b
变量中,相同位置上,分别取出一位,负责完成00->01->10->00
,也就是开头的那句话,当数字出现3次时置零。
- x & ~x = 0;
- x & ~0 = x;
猜数字大小游戏
我们正在玩一个猜数游戏,游戏规则如下:
我从 1 到 n 之间选择一个数字,你来猜我选了哪个数字。
每次你猜错了,我都会告诉你,我选的数字比你的大了或者小了。
然而,当你猜了数字 x 并且猜错了的时候,你需要支付金额为 x 的现金。直到你猜到我选的数字,你才算赢得了这个游戏。
示例:
n = 10, 我选择了8.
第一轮: 你猜我选择的数字是5,我会告诉你,我的数字更大一些,然后你需要支付5块。
第二轮: 你猜是7,我告诉你,我的数字更大一些,你支付7块。
第三轮: 你猜是9,我告诉你,我的数字更小一些,你支付9块。游戏结束。8 就是我选的数字。
你最终要支付 5 + 7 + 9 = 21 块钱。
给定 n ≥ 1,计算你至少需要拥有多少现金才能确保你能赢得这个游戏。
class Solution {
public:
int getMoneyAmount(int n) {
vector<vector<int>> dp(n + 1, vector<int>(n + 1, 0));
for(int i = n - 1; i >= 1; i--) {
for (int j = i + 1; j <= n; j++) {
dp[i][j] = INT_MAX;
for (int k = j - 1; k >= i; k -= 2)
dp[i][j] = min(dp[i][j], k + max(dp[i][k - 1], dp[k + 1][j]));
}
}
return dp[1][n];
}
};
/**
dp[i][j]表示从[i,j]中猜出正确数字所需要的最少花费金额.(dp[i][i] = 0)
假设在范围[i,j]中选择x, 则选择x的最少花费金额为: max(dp[i][x-1], dp[x+1][j]) + x
用max的原因是我们要计算最坏反馈情况下的最少花费金额(选了x之后, 正确数字落在花费更高的那侧)
初始化为(n+2)*(n+2)数组的原因: 处理边界情况更加容易, 例如对于求解dp[1][n]时x如果等于1, 需要考虑dp[0][1](0不可能出现, dp[0][n]为0)
而当x等于n时, 需要考虑dp[n+1][n+1](n+1也不可能出现, dp[n+1][n+1]为0)
如何写出相应的代码更新dp矩阵, 递推式dp[i][j] = max(max(dp[i][x-1], dp[x+1][j]) + x), x~[i:j], 可以画出矩阵图协助理解, 可以发现
dp[i][x-1]始终在dp[i][j]的左部, dp[x+1][j]始终在dp[i][j]的下部, 所以更新dp矩阵时i的次序应当遵循bottom到top的规则, j则相反, 由于
i肯定小于等于j, 所以我们只需要遍历更新矩阵的一半即可(下半矩阵)
**/
日程表安排
实现一个 MyCalendar 类来存放你的日程安排。如果要添加的时间内没有其他安排,则可以存储这个新的日程安排。
MyCalendar 有一个 book(int start, int end)方法。它意味着在 start 到 end 时间内增加一个日程安排,注意,这里的时间是半开区间,即 [start, end), 实数 x 的范围为, start <= x < end。
当两个日程安排有一些时间上的交叉时(例如两个日程安排都在同一时间内),就会产生重复预订。
每次调用 MyCalendar.book方法时,如果可以将日程安排成功添加到日历中而不会导致重复预订,返回 true。否则,返回 false 并且不要将该日程安排添加到日历中。
请按照以下步骤调用 MyCalendar 类: MyCalendar cal = new MyCalendar(); MyCalendar.book(start, end)
示例 1:
MyCalendar();
MyCalendar.book(10, 20); // returns true
MyCalendar.book(15, 25); // returns false
MyCalendar.book(20, 30); // returns true
解释:
第一个日程安排可以添加到日历中. 第二个日程安排不能添加到日历中,因为时间 15 已经被第一个日程安排预定了。
第三个日程安排可以添加到日历中,因为第一个日程安排并不包含时间 20 。
class MyCalendar {
public:
list<pair<int, int>> myList;//存储已经插入不重叠的日程
MyCalendar() {
}
bool book(int start, int end) {
auto it = myList.begin();//扫描链表,获取第一个与{start, end - 1}有重叠的迭代器
while (it != myList.end() && it->second < start) {
++it;
}
//it == myList.end() 代表没有找到有交集的位置,it->first >= end代表的是{start, end - 1}在两个日程中间
if (it == myList.end() || it->first >= end) {
myList.insert(it, { start, end - 1 });//插入到it这个位置
return true;
}
return false;
}
};
合并两个有序链表
输入两个单调递增的链表,输出两个链表合成后的链表,当然我们需要合成后的链表满足单调不减规则。
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
if(l1==NULL)
return l2;
if(l2==NULL)
return l1;
if(l1->val < l2->val){
l1->next = mergeTwoLists(l1->next,l2);
return l1;
}else{
l2->next = mergeTwoLists(l1,l2->next);
return l2;
}
}
};
二叉搜索树的后序遍历序列
输入一个整数数组,判断该数组是不是某二叉搜索树的后序遍历的结果。如果是则输出Yes,否则输出No。假设输入的数组的任意两个数字都互不相同。
class Solution {
public:
bool VerifySquenceOfBST(vector<int> sequence) {
int size = sequence.size();
if(0==size)return false;
int i = 0;
while(--size)
{
while(sequence[i++]<sequence[size]);
while(sequence[i++]>sequence[size]);
if(i<size)return false;
i=0;
}
return true;
}
};
//非递归
//非递归也是一个基于递归的思想:
//左子树一定比右子树小,因此去掉根后,数字分为left,right两部分,right部分的
//最后一个数字是右子树的根他也比左子树所有值大,因此我们可以每次只看有子树是否符合条件
//即可,即使到达了左子树左子树也可以看出由左右子树组成的树还想右子树那样处理
//对于左子树回到了原问题,对于右子树,左子树的所有值都比右子树的根小可以暂时把他看出右子树的左子树
//只需看看右子树的右子树是否符合要求即可
二叉树中和为某一值的路径
输入一颗二叉树的跟节点和一个整数,打印出二叉树中结点值的和为输入整数的所有路径。路径定义为从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。(注意: 在返回值的list中,数组长度大的数组靠前)
/*
struct TreeNode {
int val;
struct TreeNode *left;
struct TreeNode *right;
TreeNode(int x) :
val(x), left(NULL), right(NULL) {
}
};*/
class Solution {
public:
vector<vector<int> > buffer;
vector<int> tmp;
vector<vector<int> > FindPath(TreeNode* root,int expectNumber) {
if(root==NULL)
return buffer;
tmp.push_back(root->val);
if((expectNumber-root->val)==0 && root->left==NULL && root->right==NULL)
{
buffer.push_back(tmp);
}
FindPath(root->left,expectNumber-root->val);
FindPath(root->right,expectNumber-root->val);
if(tmp.size()!=0)
tmp.pop_back();
return buffer;
}
};