目录
✅ 1217. 玩筹码
https://leetcode-cn.com/problems/play-with-chips
描述
数轴上放置了一些筹码，每个筹码的位置存在数组 chips 当中。
你可以对 任何筹码 执行下面两种操作之一（不限操作次数，0 次也可以）：
将第 i 个筹码向左或者右移动 2 个单位，代价为 0。
将第 i 个筹码向左或者右移动 1 个单位，代价为 1。
最开始的时候，同一位置上也可能放着两个或者更多的筹码。
返回将所有筹码移动到同一位置（任意位置）上所需要的最小代价。
示例 1：
输入：chips = [1,2,3]
输出：1
解释：第二个筹码移动到位置三的代价是 1，第一个筹码移动到位置三的代价是 0，总代价为 1。
示例 2：
输入：chips = [2,2,2,3,3]
输出：2
解释：第四和第五个筹码移动到位置二的代价都是 1，所以最小总代价为 2。
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/play-with-chips
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
解答
因为移动2个位置不需要代价，那么奇数位置移到奇数位置不用代价，偶数位置移到偶数位置不用代价，那就分别统计奇数位置和偶数位置的个数，相当于把所有奇数放一起，所有偶数的放一起，然后比较奇数的少还是偶数的少，将少的个数移到多的个数位置上去就可以了
c
int minCostToMoveChips(int* chips, int chipsSize){
int odd = 0, even = 0;
for(int i = 0; i < chipsSize; i++) {
if(chips[i] % 2 == 0){
even++;
} else {
odd++;
}
}
return even > odd ? odd : even;
}
/*执行用时 :
0 ms
, 在所有 C 提交中击败了
100.00%
的用户
内存消耗 :
6.7 MB
, 在所有 C 提交中击败了
99.28%
的用户*/
java
class Solution {
public int minCostToMoveChips(int[] chips) {
int odd = 0;
int even = 0;
for(int i: chips){
if(i % 2 == 0) {
even++;
} else {
odd++;
}
}
return Math.min(even, odd);
}
}
/*执行用时 :
0 ms
, 在所有 Java 提交中击败了
100.00%
的用户
内存消耗 :
41.2 MB
, 在所有 Java 提交中击败了
5.64%
的用户*/
py
class Solution:
def minCostToMoveChips(self, chips: List[int]) -> int:
even = 0
for i in chips:
if i&1 == 0:
even+=1
return min(even, len(chips) - even)
'''执行用时 :
32 ms
, 在所有 Python3 提交中击败了
87.26%
的用户
内存消耗 :
13 MB
, 在所有 Python3 提交中击败了
54.84%
的用户'''
✅ 206. 反转链表
https://leetcode-cn.com/problems/reverse-linked-list
描述
反转一个单链表。
示例:
输入: 1->2->3->4->5->NULL
输出: 5->4->3->2->1->NULL
进阶:
你可以迭代或递归地反转链表。你能否用两种方法解决这道题？
解答
c
他人：
//递归
struct ListNode* reverseList(struct ListNode* head){
if(!head || !head->next)
return head;
struct ListNode *newhead = reverseList(head->next);//newhead指针记录链表末尾节点。
head->next->next = head;
head->next = NULL;
return newhead;
}
图片解释
java
迭代的，while loop 其实就是soldier 方式了：
/**
* Definition for singly-linked list.
* public class ListNode {
* int val;
* ListNode next;
* ListNode(int x) { val = x; }
* }
*/
class Solution {
public ListNode reverseList(ListNode head) {
ListNode pre = null;
ListNode curr = head;
while(curr != null) {
ListNode tmp = curr.next;
curr.next = pre;
pre = curr;
curr = tmp;
}
return pre;
}
}
/*执行用时 :
0 ms
, 在所有 Java 提交中击败了
100.00%
的用户
内存消耗 :
42.3 MB
, 在所有 Java 提交中击败了
5.26%
的用户*/
py
# Definition for singly-linked list.
# class ListNode:
# def __init__(self, x):
# self.val = x
# self.next = None
class Solution:
def reverseList(self, head: ListNode) -> ListNode:
cur, pre = head, None
while cur:
pre, pre.next, cur = cur, pre, cur.next
return pre
'''执行用时 :
52 ms
, 在所有 Python3 提交中击败了
21.50%
的用户
内存消耗 :
14.2 MB
, 在所有 Python3 提交中击败了
62.26%
的用户'''
图片解释：
✅ 922. 按奇偶排序数组 II
https://leetcode-cn.com/problems/sort-array-by-parity-ii
描述
给定一个非负整数数组 A， A 中一半整数是奇数，一半整数是偶数。
对数组进行排序，以便当 A[i] 为奇数时，i 也是奇数；当 A[i] 为偶数时， i 也是偶数。
你可以返回任何满足上述条件的数组作为答案。
示例：
输入：[4,2,5,7]
输出：[4,5,2,7]
解释：[4,7,2,5]，[2,5,4,7]，[2,7,4,5] 也会被接受。
提示：
2 <= A.length <= 20000
A.length % 2 == 0
0 <= A[i] <= 1000
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/sort-array-by-parity-ii
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
解答
c 双指针soldier
class Solution {
public:
vector<int> sortArrayByParityII(vector<int>& A) {
int i ,l=A.size(),j,temp;
for(i=0,j=1;i<l&&j<l;)
{
while(i<l&&A[i]%2==0)
{
i+=2;
}
while(j<l&&A[j]%2==1)
{
j+=2;
}
if(i<l&&j<l)
{
temp=A[i];
A[i]=A[j];
A[j]=temp;
}
}
return A;
}
};
tddo fix: my c (0214 fixed)
非常奇怪，看着和上面的一样啊。
/**
* Note: The returned array must be malloced, assume caller calls free().
*/
int* sortArrayByParityII(int* A, int ASize, int* returnSize){
int i, j, tmp;
for(i = 0, j = 1; i < ASize && j < ASize;){
while(i < ASize && (A[i] % 2 == 0)){
//even, ok for i soldier, move foward
i+=2;
}
while(j < ASize && (A[j] % 2 == 1)){
//odd, ok for j soldier, move foward
j+=2;
}
if(i < ASize && j < ASize) {
tmp = A[i];
A[i] = A[j];
A[j] = A[i];
}
}
*returnSize = ASize;
return A;
}
/*输入:
[4,2,5,7]
输出
[4,2,2,7]
预期结果
[4,5,2,7]*/
fixed: by change: A[j] = A[i] to A[j] = tmp
/**
* Note: The returned array must be malloced, assume caller calls free().
*/
int* sortArrayByParityII(int* A, int ASize, int* returnSize){
int i, j, tmp;
for(i = 0, j = 1; (i < ASize) && (j < ASize);){
while(i < ASize && (A[i] % 2 == 0)){
//even, ok for i soldier, move foward
i+=2;
}
while(j < ASize && (A[j] % 2 == 1)){
//odd, ok for j soldier, move foward
j+=2;
}
if(i < ASize && j < ASize) {
tmp = A[i];
A[i] = A[j];
A[j] = tmp;//tt i was fucked here, plz don't use: A[j] = A[i]; fuxkkk
}
}
*returnSize = ASize;
return A;
}
/*执行用时 :
80 ms
, 在所有 C 提交中击败了
81.63%
的用户
内存消耗 :
14.1 MB
, 在所有 C 提交中击败了
96.14%
的用户*/
java 内部实际上是选择排序
class Solution {
public int[] sortArrayByParityII(int[] A) {
int j = 1;
for (int i = 0; i < A.length - 1; i = i + 2) {
if ((A[i] & 1) != 0) {
//实际上是选择排序
while ((A[j] & 1) != 0) {
j = j + 2;
}
int tmp = A[i];
A[i] = A[j];
A[j] = tmp;
}
}
return A;
}
}
py
todo 深刻理解zip
class Solution:
def sortArrayByParityII(self, A):
"""
:type A: List[int]
:rtype: List[int]
"""
ou = [i for i in A if i % 2]
ji = [i for i in A if not i % 2]
return [i for n in zip(ji, ou) for i in n]
✅ 867. 转置矩阵
https://leetcode-cn.com/problems/transpose-matrix
描述
给定一个矩阵 A， 返回 A 的转置矩阵。
矩阵的转置是指将矩阵的主对角线翻转，交换矩阵的行索引与列索引。
示例 1：
输入：[[1,2,3],[4,5,6],[7,8,9]]
输出：[[1,4,7],[2,5,8],[3,6,9]]
示例 2：
输入：[[1,2,3],[4,5,6]]
输出：[[1,4],[2,5],[3,6]]
来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/transpose-matrix
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。
解答
c
int** transpose(int** A, int ARowSize, int *AColSizes, int** columnSizes, int* returnSize)
{
int i, j;
int** ret = (int**)malloc(sizeof(int*) * (*AColSizes));
columnSizes[0] = (int*)malloc(sizeof(int) * (*AColSizes));
*returnSize = *AColSizes;
for(i = 0; i < *AColSizes; i++) columnSizes[0][i] = ARowSize;
for(i = 0; i < *AColSizes; i++) ret[i] = (int*)malloc(sizeof(int) * ARowSize);
for(i = 0; i < ARowSize; i++)
{
for(j = 0; j < *AColSizes; j++)
{
ret[j][i] = A[i][j];
}
}
return ret;
}
图片解释 上述：
二维数组需要两次dereference, there is why:
java
class Solution {
public int[][] transpose(int[][] A) {
int d1 = A.length;
int d2 = A[0].length;
int[][] ans = new int[d2][d1];
for(int i = 0; i < d1; i++){
for(int j = 0; j < d2; j++){
ans[j][i] = A[i][j];
}
}
return ans;
}
}
/*执行用时 :
0 ms
, 在所有 Java 提交中击败了
100.00%
的用户
内存消耗 :
48.1 MB
, 在所有 Java 提交中击败了
5.15%
的用户*/
py
class Solution:
def transpose(self, A: List[List[int]]) -> List[List[int]]:
return zip(*A)
'''1 小时前 通过 88 ms 13.9 MB Python3
'''