init

24/11/3226.cpp

@@ -0,0 +1,26 @@
+
+int minChanges(int n, int k)
+{
+    if(n<k){
+        return 1;
+    }
+    int count = 0;
+    while (n || k == 0)
+    {
+        if ((n & 1) < (k & 1))
+        {
+            return -1;
+        }
+        if ((n & 1) > (k & 1))
+        {
+            count++;
+        }
+        n >>= 1;
+        k >>= 1;
+    }
+    return count;
+}
+
+int minChanges1(int n, int k) {
+        return (n & k) == k ? __builtin_popcount(n ^ k) : -1;
+}

24/11/3243.cpp

@@ -0,0 +1,27 @@
+#include <vector>
+using namespace std;
+
+vector<int> shortestDistanceAfterQueries(int n, vector<vector<int>> &queries)
+{
+    vector<vector<int>> prev(n);
+    vector<int> dp(n);
+    for (int i = 1; i < n; i++)
+    {
+        prev[i].push_back(i - 1);
+        dp[i] = i;
+    }
+    vector<int> res;
+    for (auto &query : queries)
+    {
+        prev[query[1]].push_back(query[0]);
+        for (int v = query[1]; v < n; v++)
+        {
+            for (int u : prev[v])
+            {
+                dp[v] = min(dp[v], dp[u] + 1);
+            }
+        }
+        res.push_back(dp[n - 1]);
+    }
+    return res;
+}

24/11/3258.cpp

@@ -0,0 +1,36 @@
+#include <string>
+#include <iostream>
+using namespace std;
+
+int countKConstraintSubstrings(string s, int k)
+{
+    int a, b;
+    int count = 0;
+    for (int i = 1; i <= s.length(); i++)
+    {
+        int j = 0;
+        while (j + i <= s.length())
+        {
+            a = 0;
+            b = 0;
+            for (int k = j; k < j + i; k++)
+            {
+                if (s[k] == '0')
+                {
+                    a++;
+                }
+                else
+                {
+                    b++;
+                }
+            }
+            if (a <= k || b <= k)
+            {
+                count++;
+                cout << j << " " << j + i << " " << a << " " << b << endl;
+            }
+            j++;
+        }
+    }
+    return count;
+}

24/11/3259.cpp

@@ -0,0 +1,51 @@
+#include <vector>
+#include <iostream>
+#include "math.h"
+
+using namespace std;
+
+// 3259. 能量提升
+// 动态规划+贪心 递推式：dp[i] += max(now[i-1], next[i-2])
+long long maxEnergyBoost(vector<int> &energyDrinkA, vector<int> &energyDrinkB)
+{
+    int n = energyDrinkA.size();
+    vector<vector<long long>> dp(n + 1, vector<long long>(2, 0));
+    dp[1][0] = energyDrinkA[0];
+    dp[1][1] = energyDrinkB[0];
+    for (int i = 2; i <= n; i++)
+    {
+        dp[i][0] = energyDrinkA[i - 1] + max(dp[i - 1][0], dp[i - 2][1]);
+        dp[i][1] = energyDrinkB[i - 1] + max(dp[i - 1][1], dp[i - 2][0]);
+    }
+    return max(dp[n][0], dp[n][1]);
+}
+
+long long maxEnergyBoost(int* energyDrinkA, int energyDrinkASize, int* energyDrinkB, int energyDrinkBSize) {
+    int n = energyDrinkASize;
+    long long **dp = (long long **)malloc(sizeof(long long *) * 2);
+    dp[0] = (long long *)malloc(sizeof(long long) * (n + 1));
+    dp[1] = (long long *)malloc(sizeof(long long) * (n + 1));
+    dp[0][0] = 0;
+    dp[1][0] = 0;
+    dp[0][1] = energyDrinkA[0];
+    dp[1][1] = energyDrinkB[0];
+    for (int i = 2; i <= n; i++)
+    {
+        dp[0][i] = energyDrinkA[i-1] + fmax(dp[0][i-1], dp[1][i-2]);
+        dp[1][i] = energyDrinkB[i-1] + fmax(dp[1][i-1], dp[0][i-2]);
+    }
+    return fmax(dp[0][n], dp[1][n]);
+}
+
+
+// 空间优化
+long long maxEnergyBoost1(int* energyDrinkA, int energyDrinkASize, int* energyDrinkB, int energyDrinkBSize) {
+    int n = energyDrinkASize;
+    long long tmp[3]={energyDrinkA[0],energyDrinkB[0],energyDrinkA[0]};
+    for (int i = 1; i < energyDrinkASize; i++) {
+        tmp[0]=fmax(tmp[0]+energyDrinkA[i],tmp[1]);
+        tmp[1]=fmax(tmp[1]+energyDrinkB[i],tmp[2]);
+        tmp[2]=tmp[0];
+    }
+    return fmax(tmp[0],tmp[1]);
+}

24/11/Llist.c

@@ -0,0 +1,108 @@
+#include <stdlib.h>
+
+typedef struct ListNode
+{
+    int val;
+    ListNode *next;
+} ListNode;
+
+
+// 若使用了带头节点的链表，则无需判断head是否为空
+ListNode *createListNode(int val)
+{
+    ListNode *node = (ListNode *)malloc(sizeof(ListNode));
+    node->val = val;
+    node->next = NULL;
+    return node;
+}
+
+void printList(ListNode *head)
+{
+    ListNode *temp = head;
+    while(temp){
+        printf("%d ",temp->val);
+        temp = temp->next;
+    }
+    printf("\n");
+}
+
+// 添加节点
+ListNode *addNode(ListNode *head,int val)
+{
+    if(head == NULL){
+        head = createListNode(val);
+        return head;
+    }
+    ListNode *temp = head;
+    while(temp->next){
+        temp = temp->next;
+    }
+    ListNode *node = (ListNode *)malloc(sizeof(ListNode));
+    node->val = val;
+    node->next = NULL;
+    temp->next = node;
+    return head;
+}
+
+int Locate(ListNode *head,int val){
+    if(head == NULL){
+        return -1;
+    }
+    ListNode *temp = head;
+    int index = 0;
+    while(temp){
+        if(temp->val==val){
+            return index;
+        }
+        temp = temp->next;
+        index++;
+    }
+    return -1;
+}
+
+// 删除节点
+ListNode *deleteNode(ListNode *head,int val){
+    if(head == NULL){
+        return NULL;
+    }
+
+    ListNode *temp1 = head;
+    if(temp1->val == val){
+        head = temp1->next;
+        free(temp1);
+        return head;
+    }
+
+    ListNode *temp2 = head->next;
+    while (temp2)
+    {
+        if(temp2->val == val){
+            temp1->next = temp2->next;
+            free(temp2);
+            return head;
+        }
+        temp1 = temp1->next;
+        temp2 = temp2->next;
+    }
+    return head;
+}
+
+ListNode *insertNode(ListNode *head,int val,int index){
+    if(head == NULL){
+        head = createListNode(val);
+        return head;
+    }
+
+    ListNode *temp = head;
+    int i = 0;
+    while(i < index-1 && temp){
+        temp = temp->next;
+        i++;
+    }
+
+    ListNode *node = (ListNode *)malloc(sizeof(ListNode));
+    node->val = val;
+    node->next = temp->next;
+    temp->next = node;
+    return head;
+}

24/11/euclidean.c

@@ -0,0 +1,66 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+#define MaxSize 100
+
+struct stacks{
+    int data[MaxSize];
+    int top;
+};
+
+char *euclidean(int n, int r){
+    struct stacks s;
+    s.top = -1;
+
+    // 检查基数范围
+    if (r < 2 || r > 36) {
+        return NULL; // 无效的基数
+    }
+
+    // 处理 n 为 0 的情况
+    if (n == 0) {
+        char *result = (char *)malloc(2);
+        if (!result) return NULL; // 内存分配失败
+        result[0] = '0';
+        result[1] = '\0';
+        return result;
+    }
+
+    // 处理负数
+    int isNegative = 0;
+    if (n < 0) {
+        isNegative = 1;
+        n = -n;
+    }
+
+    while(n > 0){
+        if (s.top + 1 >= MaxSize) {
+            return NULL; // 栈溢出
+        }
+        s.data[++s.top] = n % r;
+        n = n / r;
+    }
+
+    // 计算需要的内存大小：字符数 + 可能的负号 + 终止符
+    int size = s.top + 1 + isNegative + 1;
+    char *result = (char *)malloc(sizeof(char) * size);
+    if (!result) {
+        return NULL; // 内存分配失败
+    }
+
+    int i = 0;
+    if (isNegative) {
+        result[i++] = '-';
+    }
+
+    while(s.top != -1){
+        int value = s.data[s.top--];
+        if (value < 10) {
+            result[i++] = '0' + value;
+        } else {
+            result[i++] = 'A' + (value - 10);
+        }
+    }
+    result[i] = '\0';
+    return result;
+}

24/11/length.cpp

@@ -0,0 +1,38 @@
+#include "tree.c"
+
+TreeNode* findLCA(TreeNode* root, int node1, int node2) {
+    if (root == NULL || root->val == node1 || root->val == node2) {
+        return root;
+    }
+
+    TreeNode* left = findLCA(root->left, node1, node2);
+    TreeNode* right = findLCA(root->right, node1, node2);
+
+    if (left != NULL && right != NULL) {
+        return root;
+    }
+
+    return (left != NULL) ? left : right;
+}
+
+int findLevel(TreeNode* root, int val, int level) {
+    if (root == NULL) return -1;
+    if (root->val == val) return level;
+
+    int left = findLevel(root->left, val, level + 1);
+    if (left != -1) return left;
+
+    return findLevel(root->right, val, level + 1);
+}
+
+int nodeDistance(TreeNode *root, int node1, int node2) {
+    TreeNode* lca = findLCA(root, node1, node2);
+    if (lca == NULL) return -1;
+
+    int d1 = findLevel(lca, node1, 0);
+    int d2 = findLevel(lca, node2, 0);
+
+    if (d1 == -1 || d2 == -1) return -1;
+
+    return d1 + d2;
+}

24/11/tree.c

@@ -0,0 +1,219 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <time.h>
+
+typedef struct TreeNode
+{
+    int val;
+    struct TreeNode *left;
+    struct TreeNode *right;
+} TreeNode;
+
+typedef struct StackNode
+{
+    TreeNode *treeNode;
+    struct StackNode *next;
+} StackNode;
+
+typedef struct Stack
+{
+    StackNode *top;
+} Stack;
+
+void push(Stack *stack, TreeNode *treeNode)
+{
+    StackNode *newNode = (StackNode *)malloc(sizeof(StackNode));
+    newNode->treeNode = treeNode;
+    newNode->next = stack->top;
+    stack->top = newNode;
+}
+
+TreeNode *pop(Stack *stack)
+{
+    if (stack->top == NULL)
+    {
+        return NULL;
+    }
+    StackNode *temp = stack->top;
+    TreeNode *treeNode = temp->treeNode;
+    stack->top = stack->top->next;
+    free(temp);
+    return treeNode;
+}
+
+int isEmpty(Stack *stack)
+{
+    return stack->top == NULL;
+}
+
+void preorder(TreeNode *root)
+{
+    if (root == NULL)
+    {
+        return;
+    }
+
+    Stack stack = {NULL};
+    TreeNode *p = root;
+    while (p != NULL || !isEmpty(&stack))
+    {
+        while (p != NULL)
+        {
+            printf("%d ", p->val);
+            push(&stack, p);
+            p = p->left;
+        }
+        p = pop(&stack);
+        p = p->right;
+    }
+}
+
+void inorder(TreeNode *root)
+{
+    if (root == NULL)
+    {
+        return;
+    }
+
+    Stack stack = {NULL};
+    TreeNode *p = root;
+    while (p != NULL || !isEmpty(&stack))
+    {
+        while (p != NULL)
+        {
+            push(&stack, p);
+            p = p->left;
+        }
+        p = pop(&stack);
+        printf("%d ", p->val);
+        p = p->right;
+    }
+}
+
+void postorder(TreeNode *root)
+{
+    if (root == NULL)
+    {
+        return;
+    }
+
+    Stack stack = {NULL};
+    TreeNode *p = root;
+    TreeNode *pre = NULL;
+    do
+    {
+        while (p != NULL)
+        {
+            push(&stack, p);
+            p = p->left;
+        }
+        p = pop(&stack);
+        if (p->right == NULL || p->right == pre)
+        {
+            printf("%d ", p->val);
+            pre = p;
+            p = NULL;
+        }
+        else
+        {
+            push(&stack, p);
+            p = p->right;
+        }
+    } while (!isEmpty(&stack));
+}
+
+void Postorderd(TreeNode *root)
+{
+    if (root == NULL)
+    {
+        return;
+    }
+    Postorderd(root->left);
+    Postorderd(root->right);
+    printf("%d ", root->val);
+}
+
+
+TreeNode* createTreeNode(int val) {
+    TreeNode* node = (TreeNode*)malloc(sizeof(TreeNode));
+    node->val = val;
+    node->left = NULL;
+    node->right = NULL;
+    return node;
+}
+
+TreeNode* generateCompleteBinaryTree(int nodeCount) {
+    if (nodeCount <= 0) {
+        return NULL;
+    }
+
+    srand(time(NULL));
+    TreeNode** nodes = (TreeNode**)malloc(nodeCount * sizeof(TreeNode*));
+    for (int i = 0; i < nodeCount; i++) {
+        nodes[i] = createTreeNode(rand() % 100 + 1);
+    }
+
+    for (int i = 0; i < nodeCount; i++) {
+        if (2 * i + 1 < nodeCount) {
+            nodes[i]->left = nodes[2 * i + 1];
+        }
+        if (2 * i + 2 < nodeCount) {
+            nodes[i]->right = nodes[2 * i + 2];
+        }
+    }
+
+    TreeNode* root = nodes[0];
+    free(nodes);
+    return root;
+}
+
+void printTreeStructure(TreeNode* root) {
+    if (root == NULL) {
+        return;
+    }
+    printf("%d ", root->val);
+    if (root->left != NULL || root->right != NULL) {
+        printf("(");
+        printTreeStructure(root->left);
+        printf(", ");
+        printTreeStructure(root->right);
+        printf(")");
+    }
+}
+
+/*
+生成的二叉树结构如下：
+
+           2
+         /   \
+       /       \
+      4         7
+    /   \      / \
+   9     11  22  44
+  / \   /
+ 66 88 99
+
+*/
+TreeNode* generateSpecificBinaryTree() 
+{
+    int values[] = {2, 4, 7, 9, 11, 22, 44, 66, 88, 99};
+    int nodeCount = sizeof(values) / sizeof(values[0]);
+
+    TreeNode** nodes = (TreeNode**)malloc(nodeCount * sizeof(TreeNode*));
+    for (int i = 0; i < nodeCount; i++) {
+        nodes[i] = createTreeNode(values[i]);
+    }
+
+    for (int i = 0; i < nodeCount; i++) {
+        if (2 * i + 1 < nodeCount) {
+            nodes[i]->left = nodes[2 * i + 1];
+        }
+        if (2 * i + 2 < nodeCount) {
+            nodes[i]->right = nodes[2 * i + 2];
+        }
+    }
+
+    TreeNode* root = nodes[0];
+    free(nodes);
+    return root;
+}