Surrounded Regions
题目描述
Given a 2D board containing'X'and'O', capture all regions surrounded by'X'.A region is captured by flipping all'O's into'X's in that surrounded region .
For example,
| 1 2 3 4 5 | X X X X X O O X X X O X X O X X |
After running your function, the board should be:
| 1 2 3 4 5 | X X X X X X X X X X X X X O X X |
解题思路
这道题的意思是，将边界及所有与边界相连的O予以保留，其它的O变为X。
所以我们可以采取的思路是，将边界及所有与边界相连的O先行转换成别的字母，例如S。然后遍历整个矩阵，将所有的O变为X，所有的S变为O，这样就完成了任务。
代码实现
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 | void toS(vector<vector<char>> &board, int i, int j,int rows, int cols) { if (i < 0 || j < 0 || i >= rows || j >= cols) return; if (board[i][j] == 'O') { board[i][j] = 'S'; toS(board, i + 1, j, rows, cols); toS(board, i - 1, j, rows, cols); toS(board, i, j - 1, rows, cols); toS(board, i, j + 1, rows, cols); } } void solve(vector<vector<char>> &board) { int rows = board.size();//行数 int cols = board[0].size();//列数 if (rows <= 2 || cols <= 2) return; //第一行 for (int i = 0; i < cols; i++) { if (board[0][i] == 'O') toS(board, 0, i,rows,cols); } //最后一行 for (int i = 0; i < cols; i++) { if (board[rows - 1][i] == 'O') toS(board, rows - 1, i, rows, cols); } //第一列 for (int i = 1; i < rows - 1; i++) { if (board[i][0] == 'O') toS(board, i, 0, rows, cols); } //最后一列 for (int i = 1; i < rows - 1; i++) { if (board[i][cols - 1]=='O') toS(board, i, cols - 1, rows, cols); } for (int i = 0; i < rows; i++) { for (int j = 0; j < cols; j++) { if (board[i][j] == 'O') board[i][j] = 'X'; else if (board[i][j] == 'S') board[i][j] = 'O'; } } } |
Valid-Parentheses
题目描述
给定一个只包括 '('，')'，'{'，'}'，'['，']' 的字符串，判断字符串是否有效。
有效字符串需满足：
1. 左括号必须用相同类型的右括号闭合。
2. 左括号必须以正确的顺序闭合。
3. 注意空字符串可被认为是有效字符串。
示例 1:
| 1 2 3 | 输入: "()" 输出: true |
示例 2:
| 1 2 3 | 输入: "()[]{}" 输出: true |
示例 3:
| 1 2 3 | 输入: "(]" 输出: false |
示例 4:
| 1 2 3 | 输入: "([)]" 输出: false |
示例 5:
| 1 2 3 | 输入: "{[]}" 输出: true |
题目解析
这种匹配问题，我们有这种思想，可以用栈来解决这个问题。因为合法的匹配实际上是类似于{[()]}这样的匹配，你会发现先输入的符号相匹配的右半边是最后输入，也就是说符合栈先入后出的特性。当pop完了这个栈为空，那就说明匹配。所以我们可以设计这这样一个算法：遍历整个字符串的每一个字符，然后：
1. 如果字符是左侧符号（如{）那么我们就向堆栈里面push进去；([
2. 当字符不是左侧符号的时候，首先要判断堆栈此时是否为空，若为空返回false，因为左侧符号还未匹配完；如果栈不为空，判断此时栈顶元素是否与当前元素相等，若不相等，也返回flase；若相等，pop出来，继续走下去。
3.当所有字符遍历完，这个时候判断栈是否为空，若为空说明都匹配，返回true，否则返回false。
代码实现
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | bool isValid(string s) { int slen = s.size(); if (slen == 0) return true; if (slen < 2) return false; stack<char>cstack; for (int i = 0; i < slen; i++) { if (s[i] == '(') cstack.push(')'); else if (s[i] == '[') cstack.push(']'); else if (s[i] == '{') cstack.push('}'); else if (cstack.empty() || cstack.top() != s[i]) return false; else cstack.pop(); } return cstack.empty(); } |
remove-nth-node-from-end-of-list
题目描述
Given a linked list, remove the n th node from the end of list and return its head.
Given linked list: 1->2->3->4->5, and n = 2.
After removing the second node from the end, the linked list becomes 1->2->3->5.
Note: Given n will always be valid.Try to do this in one pass.
解题思路
要求只能走一次路径，所以启发我们使用快慢指针。由于给予n总是合法的，所以我们不需要判断n是否超过链表长度（如果需要判断的话，必然不可能只走一趟）。
假设我们的链表是1->2->3->4->5，且n=2。那么我们初始状态下，链表如下：
第一步，首先建立一个头指针，命名为dummy，算是一个pivot，然后令head也指向这个dummy。
第二步，新建快指针pfast、慢指针pslow，然后分别指向dummy。
到目前为止，链表关系如下图所示：
第三步，这一步很关键。就是后移pfast指针n个位置，在这里就是2个位置。结果如下：
第四步，在完成上述操作之后，开始同时移动pfast和pslow，直到pfast的next指针为空的时候停止移动。这个时候的结果如下：
第五步，我们新建一个链表指针指向pslow的next，命名为delp节点，这就是我们待删除的位置。然后令pslow的next指向5的地址（pslow->next=pslow->next->next）。
第六步，删除delp节点，也就是执行delete(delp)命令。
最后，返回dummy->next即可。结果如下：
代码实现
| 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 | ListNode *removeNthFromEnd(ListNode *head, int n) { if (head == NULL) return head; ListNode *dummy = new ListNode(-1); dummy->next = head; head = dummy; ListNode *pslow = head; ListNode *pfast = head; while (n--) { pfast = pfast->next; } while (pfast->next != NULL) { pslow = pslow->next; pfast = pfast->next; } ListNode *delp = pslow->next; pslow->next = pslow->next->next; delete delp; return dummy->next; } |
