2022.7.31

/**
 * Definition for singly-linked list.
 * struct ListNode {
 *     int val;
 *     ListNode *next;
 *     ListNode() : val(0), next(nullptr) {}
 *     ListNode(int x) : val(x), next(nullptr) {}
 *     ListNode(int x, ListNode *next) : val(x), next(next) {}
 * };
 */
class Solution {
public:
    bool isPalindrome(ListNode* head) {
        vector<int>v;
        while(head!=nullptr){
            v.emplace_back(head->val);
            head=head->next;
        }
        int n=v.size();
        int left=0,right=n-1;
        while(left<right){
            if(v[left]!=v[right]){
                return false;
            }
            left++;
            right--;
        }
        return true;

    }
};

class Solution {
private:
    vector<vector<int>> f;
    vector<vector<string>> ret;
    vector<string> ans;
    int n;

public:
    void dfs(const string& s, int i) {
        if (i == n) {
            ret.push_back(ans);
            return;
        }
        for (int j = i; j < n; ++j) {
            if (f[i][j]) {
                ans.push_back(s.substr(i, j - i + 1));
                dfs(s, j + 1);
                ans.pop_back();
            }
        }
    }

    vector<vector<string>> partition(string s) {
        n = s.size();
        f.assign(n, vector<int>(n, true));

        for (int i = n - 1; i >= 0; --i) {
            for (int j = i + 1; j < n; ++j) {
                f[i][j] = (s[i] == s[j]) && f[i + 1][j - 1];
            }
        }

        dfs(s, 0);
        return ret;
    }
};

class Solution {
public:
    bool isPrim(int x) { 
        if (x == 1) {
            return false;
        }
        for (int i = 2; i <= sqrt(x); i++) {
            if (x % i == 0) {
                return false;
            }
        }
        return true;
    }

    int primePalindrome(int n) {
        int left = 1;
        while (1) {
            int right = left * 10;
            for (int op = 0; op < 2; op++) {
                for (int i = left; i < right; i++) {
                    int sum = i;
                    int x = (op == 0) ? i / 10 : i;
                    while (x > 0) {
                        sum = sum * 10 + x % 10;
                        x /= 10;
                    }
                    if (sum >= n && isPrim(sum)) { 
                        return sum;
                    }
                }
            }
            left = right;
        }
        return 1;
    }
};

class Solution {
public:
    int countPrimes(int n) {
        vector<int> primes;
        vector<int> isPrime(n, 1);
        for (int i = 2; i < n; ++i) {
            if (isPrime[i]) {
                primes.push_back(i);
            }
            for (int j = 0; j < primes.size() && i * primes[j] < n; ++j) {
                isPrime[i * primes[j]] = 0;
                if (i % primes[j] == 0) {
                    break;
                }
            }
        }
        return primes.size();
    }
};