leetcode-24-exercise

506. Relative Ranks

解题思路:

使用priority_queue。它在插入时会将数据按照由大到小的顺序插入,自然排序了。所以插入时考虑插入pair<nums[i],i>,然后根据i填充result。

注意,1) priority_queue没有迭代器,所以要遍历只能通过pop操作

2) vector要注意初始化,不然访问时可能有问题

#include <queue>
class Solution {
public:
    vector<string> findRelativeRanks(vector<int>& nums) {
        vector<string> result(nums.size(), "");
        priority_queue<pair<int, int> > p;
        for (int i = 0; i < nums.size(); i++) {
            p.push(make_pair(nums[i], i));
        }
        int count = 0;
        while (p.empty() == false) {
            if (count == 0) {
                result[p.top().second] = "Gold Medal";
            }
            else if (count == 1) {
                result[p.top().second] = "Silver Medal";
            }
            else if (count == 2) {
                result[p.top().second] = "Bronze Medal";
            }
            else
                result[p.top().second] = to_string(count + 1);
            p.pop();
            count ++;
        }
        return result;
    }
};

  



551. Student Attendance Record I

解题思路:

这道题需要注意的是,L不能连续。所以只要看L的次数有没有到2次就好了。如果1) i = 0; 2) s[i-1]不是L,s[i]是L,那么设count=0。在循序中,

最后一条语句检查A和L数目的情况。不要想复杂了,最简单的方式解决就好。

bool checkRecord(string s) {
        int a = 0;
        int count = 0;
        for (int i = 0; i < s.length(); i++) {
            if (s[i] == ‘A‘)
                a ++;
            if (s[i] == ‘L‘) {
                if (i == 0 || s[i-1] != ‘L‘)
                    count = 0;
                count ++;
            }
            if (a > 1 || count > 2)
                return false;
        }
        return true;
    }

  



556. Next Greater Element III

解题思路:

首先,返回-1的有以下几种情况:1) 只有一位数;2) 所有数字呈递减顺序,如9876这种;3) 转换后的数超出INT_MAX

因此,先将数字转化为字符串。然后从后往前,寻找递减序列。假设从i到num.length()-1是递减的,那么,现将这一段倒序,

然后将num[i-1]与这一段中第一个大于它的数交换,即可。例如14653,653是递减的,所以先变为14356,然后交换4和5,

变为15346。注意:最后要比较转换后的数据和INT_MAX。考虑到是字符串比对,所以需要添加长度为10的条件,免得比较

时提前终止。

int nextGreaterElement(int n) {
        if (n < 10)
            return -1;
        string num = to_string(n);
        int i;
        for (i = num.length() - 1; i >= 1; i--) {
            if (num[i-1] < num[i])
                break;
        }
        // digits descends, no answer
        if (i == 0)
            return -1;
        reverse(num.begin() + i, num.end());
        for (int j = i; j < num.length(); j++) {
            if (num[j] > num[i-1]) {
                char temp = num[j];
                num[j] = num[i-1];
                num[i-1] = temp;
                break;
            }
        }
        //cout << to_string(INT_MAX) << endl;
        // 2147483647
        if (num.size() == 10 && num > to_string(INT_MAX))
            return -1;
        return stoi(num);
    }

  



453. Minimum Moves to Equal Array Elements

解题思路:

sum() - min*length

int minMoves(vector<int>& nums) {
        int min = nums[0];
        int sum = 0;
        for (int i = 0; i < nums.size(); i++) {
            sum += nums[i];
            if (nums[i] < min)
                min = nums[i];
        }
        return sum - min * nums.size();
    }

  



414. Third Maximum Number

https://leetcode.com/problems/third-maximum-number/#/description

解题思路:

给数组排序,然后寻找第三个最大的。。如果没有,返回最大值。

注意,因为开始时取了nums[n],遍历时又从n开始,所以count只要数2就好了。

int thirdMax(vector<int>& nums) {
        sort(nums.begin(), nums.end());
        int third = nums[nums.size()-1];
        int count = 2;
        int max = third;
        for (int i = nums.size()-1; i >= 0; i--) {
            if (count > 0) {
                if (nums[i] < third){
                    third = nums[i];
                    count --;
                }
                if (count == 0)
                    break;
            }
        }
        if (count != 0)
            return max;
        else
            return third;
    }

  



326. Power of Three

Given an integer, write a function to determine if it is a power of three.

Follow up:
Could you do it without using any loop / recursion?

解题思路:

先取以3为底的对数,然后乘方,看是否与原值相等。注意:1) 3^0 = 1

2) log是自然对数,要取3的要换底。获得log(3,n)之后,要round,否则会WA在243那个值。。可能是精度原因。

bool isPowerOfThree(int n) {
        if (n == 1)
            return true;
        if (n < 3)
            return false;
        return abs(pow(3, round(log(n)/log(3))) - n) < 1e-15;
    }


367. Valid Perfect Square

Given a positive integer num, write a function which returns True if num is a perfect square else False.

Note: Do not use any built-in library function such as sqrt.

解题思路:

观察:2^2 - 1^2 = 2*1+1

3^2 - 2^2 = 2*2+1

...

x^2 - (x-1)^2 = 2*(x-1)+1

所以一个数的平方可以分解为1+3+5+....所以,只需要验证这个数是否为奇数和即可。

bool isPerfectSquare(int num) {
        int i = 1;
        while (num > 0) {
            num -= i;
            i += 2;
        }
        return num == 0;
    }

  



69. Sqrt(x)

Implement int sqrt(int x).

Compute and return the square root of x.

解题思路:

使用二分法。需要注意的是,left,right和mid要使用long,因为可能数值很大,超出int的范围。

int mySqrt(int x) {
        if (x == 1)
            return x;
        // initiate as 0
        long left = 0;
        long right = x;
        long mid = left + (right - left) / 2;
        while (left + 1 < right) {
            if (mid * mid > x)
                right = mid;
            else if (mid * mid < x)
                left = mid;
            else
                return mid;
            mid = left + (right - left) / 2;
        }
        // notice
        return left;
    }

  



  

时间: 2024-10-10 17:51:23

leetcode-24-exercise的相关文章

LeetCode(24) - Swap Nodes in Pairs

题目要求很简单,就是把list里面的node两两互换. 当做比较复杂的LinkedList的题目的时候,最好是在草稿纸上画一画,走一遍流程,凭空想很容易会出错.这一题时LeetCode 25的k=2特殊例子,所以要简单很多.用两个node,一前一后,然后两两交换就好,细节上注意的是交换后两个node前面和后面是否各自连接上.最好自己在纸上走一遍,防止出错. 代码如下: 1 /** 2 * Definition for singly-linked list. 3 * public class Li

leetcode 24

链表操作的,要注意标记头结点和边界问题. 代码如下: 1 ListNode *swapPairs(ListNode *head) { 2 if(head==NULL||head->next==NULL) 3 return head; 4 ListNode* p=head; 5 ListNode* q=head->next; 6 ListNode* x=head->next->next; 7 ListNode* t=NULL; 8 head=q; 9 while(p!=NULL&am

leetCode 24. Swap Nodes in Pairs 链表

24. Swap Nodes in Pairs Given a linked list, swap every two adjacent nodes and return its head. For example,Given 1->2->3->4, you should return the list as 2->1->4->3. Your algorithm should use only constant space. You may not modify the

[LeetCode] 24 Game 二十四点游戏

You have 4 cards each containing a number from 1 to 9. You need to judge whether they could operated through *, /, +, -, (, )to get the value of 24. Example 1: Input: [4, 1, 8, 7] Output: True Explanation: (8-4) * (7-1) = 24 Example 2: Input: [1, 2,

(Java) LeetCode 24. Swap Nodes in Pairs —— 两两交换链表中的节点

Given a linked list, swap every two adjacent nodes and return its head. Example: Given 1->2->3->4, you should return the list as 2->1->4->3. Note: Your algorithm should use only constant extra space. You may not modify the values in the

19.1.30 [LeetCode 24] Reverse Nodes in k-Group

Given a linked list, reverse the nodes of a linked list k at a time and return its modified list. k is a positive integer and is less than or equal to the length of the linked list. If the number of nodes is not a multiple of k then left-out nodes in

[刷题] LeetCode 24 Swap Nodes in Paris

要求 给定一个链表,对于每两个相邻的节点,交换其位置 示例 1->2->3->4->NULL 2->1->4->3->NULL 实现 1 struct ListNode { 2 int val; 3 ListNode *next; 4 ListNode(int x) : val(x), next(NULL) {} 5 }; 6 7 class Solution { 8 public: 9 ListNode* swapPairs(ListNode* head)

LeetCode #24 Swap Nodes in Pairs (M)

[Problem] Given a linked list, swap every two adjacent nodes and return its head. For example,Given 1->2->3->4, you should return the list as 2->1->4->3. Your algorithm should use only constant space. You may not modify the values in the

[LeetCode]24. Search Insert Position插入位置

Given a sorted array and a target value, return the index if the target is found. If not, return the index where it would be if it were inserted in order. You may assume no duplicates in the array. Here are few examples.[1,3,5,6], 5 → 2[1,3,5,6], 2 →

Java [leetcode 24]Swap Nodes in Pairs

题目描述: Given a linked list, swap every two adjacent nodes and return its head. For example, Given 1->2->3->4, you should return the list as 2->1->4->3. Your algorithm should use only constant space. You may not modify the values in the li