【算法笔记自学】第 5 章 入门篇（3）——数学问题

已于 2024-07-06 16:18:53 修改
阅读量2k 收藏
点赞数 3
分类专栏： 算法笔记自学 文章标签： 算法 笔记
于 2024-07-06 16:15:01 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_62704693/article/details/140215866
版权

5.1简单数学

#include <cstdio>
#include <algorithm>
using namespace std;
bool cmp(int a,int b){
     return a>b;
}
void to_array(int n,int num[]){
    for(int i=0;i<4;i++){
        num[i]=n%10;
        n /=10;
     }
}
int to_number(int num[]){
    int sum=0;
    for(int i=0;i<4;i++){
        sum=sum*10+num[i];
    }
    return sum;
}
int main(){
    int n,MIN,MAX;
    scanf("%d",&n);
    int num[5];
    while(1){
       to_array(n,num);
       sort(num,num+4);
       MIN=to_number(num);
       sort(num,num+4,cmp);
       MAX=to_number(num);
       n=MAX-MIN;
       printf("%04d-%04d=%04d\n",MAX,MIN,n);
       if(n==0||n==6174)break;
    }
    return 0;
}

#include <cstdio>
#include <cmath>

int main() {
    int a, b, c;
    scanf("%d%d%d", &a, &b, &c);
    int delta = b * b - 4 * a * c;
    if (delta < 0) {
        printf("No Solution");
    } else if (delta == 0) {
        printf("%.2f", -b / (2.0 * a));
    } else {
        printf("%.2f %.2f",  (-b - sqrt((double)delta)) / (2.0 * a), (-b + sqrt((double)delta)) / (2.0 * a));
    }
    return 0;
}

5.2最大公约数与最小公倍数

#include <cstdio>
#include <cmath>
int gcd(int a,int b){
    if(b==0)return a;//求最大公约数的辗转相除法递归写法
    else return gcd(b,a%b);
}
int main() {
    int m,n;
    while(scanf("%d%d",&m,&n)!=EOF){
        printf("%d\n",gcd(m,n));
    }
    return 0;
}

#include <cstdio>

int gcd(int a, int b) {
    if (b == 0) {
        return a;
    } else {
        return gcd(b, a % b);
    }
}

int main() {
    int a, b;
    scanf("%d%d", &a, &b);
    printf("%d", a / gcd(a, b) * b);
    return 0;
}

5.3分数的四则运算

#include <cstdio>
#include <algorithm>
using namespace std;

struct Fraction {
    int up, down;
};

int gcd(int a, int b) {
    if (b == 0) {
        return a;
    } else {
        return gcd(b, a % b);
    }
}

Fraction reduction(Fraction fraction) {
    if (fraction.down < 0) {
        fraction.up = -fraction.up;
        fraction.down = -fraction.down;
    }
    if (fraction.up == 0) {
        fraction.down = 1;
    } else {
        int d = gcd(abs(fraction.up), abs(fraction.down));
        fraction.up /= d;
        fraction.down /= d;
    }
    return fraction;
}

int main() {
    Fraction fraction;
    scanf("%d%d", &fraction.up, &fraction.down);
    Fraction result = reduction(fraction);
    if (result.down == 1) {
        printf("%d", result.up);
    } else {
        printf("%d %d", result.up, result.down);
    }
    return 0;
}

#include <cstdio>
#include <algorithm>
using namespace std;

struct Fraction {
    int up, down;
};

int gcd(int a, int b) {
    if (b == 0) {
        return a;
    } else {
        return gcd(b, a % b);
    }
}

Fraction reduction(Fraction fraction) {
    if (fraction.down < 0) {
        fraction.up = -fraction.up;
        fraction.down = -fraction.down;
    }
    if (fraction.up == 0) {
        fraction.down = 1;
    } else {
        int d = gcd(abs(fraction.up), abs(fraction.down));
        fraction.up /= d;
        fraction.down /= d;
    }
    return fraction;
}

Fraction add(Fraction f1, Fraction f2) {
    Fraction result;
    result.up = f1.up * f2.down + f2.up * f1.down;
    result.down = f1.down * f2.down;
    return reduction(result);
}

int main() {
    Fraction f1, f2;
    scanf("%d%d%d%d", &f1.up, &f1.down, &f2.up, &f2.down);
    Fraction result = add(f1, f2);
    if (result.down == 1) {
        printf("%d", result.up);
    } else {
        printf("%d %d", result.up, result.down);
    }
    return 0;
}

#include <cstdio>
#include <algorithm>
using namespace std;

struct Fraction {
    int up, down;
};

int gcd(int a, int b) {
    if (b == 0) {
        return a;
    } else {
        return gcd(b, a % b);
    }
}

Fraction reduction(Fraction fraction) {
    if (fraction.down < 0) {
        fraction.up = -fraction.up;
        fraction.down = -fraction.down;
    }
    if (fraction.up == 0) {
        fraction.down = 1;
    } else {
        int d = gcd(abs(fraction.up), abs(fraction.down));
        fraction.up /= d;
        fraction.down /= d;
    }
    return fraction;
}

Fraction sub(Fraction f1, Fraction f2) {
    Fraction result;
    result.up = f1.up * f2.down - f2.up * f1.down;
    result.down = f1.down * f2.down;
    return reduction(result);
}

int main() {
    Fraction f1, f2;
    scanf("%d%d%d%d", &f1.up, &f1.down, &f2.up, &f2.down);
    Fraction result = sub(f1, f2);
    if (result.down == 1) {
        printf("%d", result.up);
    } else {
        printf("%d %d", result.up, result.down);
    }
    return 0;
}

#include <cstdio>
#include <algorithm>
using namespace std;

struct Fraction {
    int up, down;
};

int gcd(int a, int b) {
    if (b == 0) {
        return a;
    } else {
        return gcd(b, a % b);
    }
}

Fraction reduction(Fraction fraction) {
    if (fraction.down < 0) {
        fraction.up = -fraction.up;
        fraction.down = -fraction.down;
    }
    if (fraction.up == 0) {
        fraction.down = 1;
    } else {
        int d = gcd(abs(fraction.up), abs(fraction.down));
        fraction.up /= d;
        fraction.down /= d;
    }
    return fraction;
}

Fraction multiply(Fraction f1, Fraction f2) {
    Fraction result;
    result.up = f1.up * f2.up;
    result.down = f1.down * f2.down;
    return reduction(result);
}

int main() {
    Fraction f1, f2;
    scanf("%d%d%d%d", &f1.up, &f1.down, &f2.up, &f2.down);
    Fraction result = multiply(f1, f2);
    if (result.down == 1) {
        printf("%d", result.up);
    } else {
        printf("%d %d", result.up, result.down);
    }
    return 0;
}

#include <cstdio>
#include <algorithm>
using namespace std;

struct Fraction {
    int up, down;
};

int gcd(int a, int b) {
    if (b == 0) {
        return a;
    } else {
        return gcd(b, a % b);
    }
}

Fraction reduction(Fraction fraction) {
    if (fraction.down < 0) {
        fraction.up = -fraction.up;
        fraction.down = -fraction.down;
    }
    if (fraction.up == 0) {
        fraction.down = 1;
    } else {
        int d = gcd(abs(fraction.up), abs(fraction.down));
        fraction.up /= d;
        fraction.down /= d;
    }
    return fraction;
}

Fraction div(Fraction f1, Fraction f2) {
    Fraction result;
    result.up = f1.up * f2.down;
    result.down = f1.down * f2.up;
    return reduction(result);
}

int main() {
    Fraction f1, f2;
    scanf("%d%d%d%d", &f1.up, &f1.down, &f2.up, &f2.down);
    Fraction result = div(f1, f2);
    if(!f2.up){
    	printf("undefined");
	}
    else if (result.down == 1) {
        printf("%d", result.up);
    } else {
        printf("%d %d", result.up, result.down);
    }
    return 0;
}

5.4素数 

#include <cstdio>
#include <algorithm>
#include <cmath>
using namespace std;
bool isPrime(int n){
    if(n<=1)return false;
    int sqr=(int)sqrt(1.0*n);
    for(int i=2;i<=sqr;i++){
        if(n%i==0)return false;
    }
    return true;

}
int main() {
    int n;
    scanf("%d",&n);
    if(isPrime(n))printf("Yes");
    else printf("No");
    return 0;
}

#include <cstdio>
#include <algorithm>
#include <cmath>
using namespace std;
bool isPrime(int n){
    if(n<=1)return false;
    int sqr=(int)sqrt(1.0*n);
    for(int i=2;i<=sqr;i++){
        if(n%i==0)return false;
    }
    return true;

}
int main() {
    int n;
    scanf("%d",&n);
    for(int i=1;i<n+1;i++)
    {
        if(isPrime(i))printf("%d\n",i);

    }
    return 0;
}

5.5质因子分解

#include <cstdio>
int main() {
    int n;
    scanf("%d", &n);
    int counter = 0;
    while (n % 2 == 0) {
        counter++;
        n /= 2;
    }
    printf("%d", counter);
    return 0;
}

#include <cstdio>
#include <cmath>
#include <cstring>
#include <vector>
using namespace std;

const int MAXN = 1000 + 1;
bool isPrime[MAXN];
vector<int> primes;

void getPrimes(int n) {
    memset(isPrime, true, sizeof(isPrime));
    for (int i = 2; i <= n; i++) {
        if (isPrime[i]) {
            primes.push_back(i);
            for (int j = i + i; j <= n; j += i) {
                isPrime[j] = false;
            }
        }
    }
}

int main() {
    int n;
    scanf("%d", &n);
    getPrimes((int)sqrt(1.0 * n));
    for (int i = 0; i < primes.size() && n > 1; i++) {
        int counter = 0;
        while (n > 1 && n % primes[i] == 0) {
            counter++;
            n /= primes[i];
        }
        if (counter > 0) {
            printf("%d %d\n", primes[i], counter);
        }
    }
    if (n > 1) {
        printf("%d 1", n);
    }
    return 0;
}

5.6大整数运算 

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

typedef vector<int> BigInt;

BigInt toBigInt(string nums) {
    BigInt result;
    for (int i = (int)nums.length() - 1; i >= 0; i--) {
        result.push_back(nums[i] - '0');
    }
    return result;
}

int compare(BigInt a, BigInt b) {
    if (a.size() > b.size()) {
        return 1;
    } else if (a.size() < b.size()) {
        return -1;
    } else {
        for (int i = (int)a.size() - 1; i >= 0; i--) {
            if (a[i] > b[i]) {
                return 1;
            } else if (a[i] < b[i]) {
                return -1;
            }
        }
        return 0;
    }
}

int main() {
    string nums1, nums2;
    cin >> nums1 >> nums2;
    BigInt a = toBigInt(nums1);
    BigInt b = toBigInt(nums2);
    int compareResult = compare(a, b);
    if (compareResult < 0) {
        printf("a < b");
    } else if (compareResult > 0) {
        printf("a > b");
    } else {
        printf("a = b");
    }
}

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

typedef vector<int> BigInt;

BigInt toBigInt(string nums) {
    BigInt result;
    for (int i = (int)nums.length() - 1; i >= 0; i--) {
        result.push_back(nums[i] - '0');
    }
    return result;
}

BigInt add(BigInt a, BigInt b) {
    BigInt c;
    int carry = 0;
    for (int i = 0; i < a.size() || i < b.size(); i++) {
        int aDigit = i < a.size() ? a[i] : 0;
        int bDigit = i < b.size() ? b[i] : 0;
        int sum = aDigit + bDigit + carry;
        c.push_back(sum % 10);
        carry = sum / 10;
    }
    if (carry) {
        c.push_back(carry);
    }
    return c;
}

void print(BigInt a) {
    for (int i = (int)a.size() - 1; i >= 0; i--) {
        cout << a[i];
    }
}

int main() {
    string nums1, nums2;
    cin >> nums1 >> nums2;
    BigInt a = toBigInt(nums1);
    BigInt b = toBigInt(nums2);
    print(add(a, b));
    return 0;
}

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

typedef vector<int> BigInt;

BigInt toBigInt(string nums) {
    BigInt result;
    for (int i = (int)nums.length() - 1; i >= 0; i--) {
        result.push_back(nums[i] - '0');
    }
    return result;
}
int compare(BigInt a, BigInt b) {
    if (a.size() > b.size()) {
        return 1;
    } else if (a.size() < b.size()) {
        return -1;
    } else {
        for (int i = (int)a.size() - 1; i >= 0; i--) {
            if (a[i] > b[i]) {
                return 1;
            } else if (a[i] < b[i]) {
                return -1;
            }
        }
        return 0;
    }
}
BigInt sub(BigInt a, BigInt b) {
    BigInt c;
    for (int i = 0; i < a.size() || i < b.size(); i++) {
        int bDigit = i < b.size() ? b[i] : 0;
        if (a[i] < bDigit) {
            a[i + 1]--;
            a[i] += 10;
        }
        c.push_back(a[i] - bDigit);
    }
     while (c.size() > 1 && c.back() == 0) {
        c.pop_back();
    }
    return c;
}

void print(BigInt a) {
    for (int i = (int)a.size() - 1; i >= 0; i--) {
        cout << a[i];
    }
}

int main() {
    string nums1, nums2;
    cin >> nums1 >> nums2;
    BigInt a = toBigInt(nums1);
    BigInt b = toBigInt(nums2);
     if (compare(a, b) >= 0) {
        print(sub(a, b));
    } else {
        cout << "-";
        print(sub(b, a));
    }
    return 0;
}

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

typedef vector<int> BigInt;

BigInt toBigInt(string nums) {
    BigInt result;
    for (int i = (int)nums.length() - 1; i >= 0; i--) {
        result.push_back(nums[i] - '0');
    }
    return result;
}
int compare(BigInt a, BigInt b) {
    if (a.size() > b.size()) {
        return 1;
    } else if (a.size() < b.size()) {
        return -1;
    } else {
        for (int i = (int)a.size() - 1; i >= 0; i--) {
            if (a[i] > b[i]) {
                return 1;
            } else if (a[i] < b[i]) {
                return -1;
            }
        }
        return 0;
    }
}
BigInt mul(BigInt a, int b) {
    BigInt c;
    int carry=0;;
    for (int i = 0; i < a.size(); i++) {
        int temp=a[i]*b+carry;
        c.push_back(temp%10);
        carry=temp/10;
    }
    while(carry!=0){
        c.push_back(carry%10);
        carry/=10;
    }
    while (c.size() > 1 && c.back() == 0) {
        c.pop_back();
    }
    return c;
}

void print(BigInt a) {
    for (int i = (int)a.size() - 1; i >= 0; i--) {
        cout << a[i];
    }
}

int main() {
     string nums;
    int b;
    cin >> nums >> b;
    BigInt a = toBigInt(nums);
    print(mul(a, b));
    return 0;
    return 0;
}

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

typedef vector<int> BigInt;

BigInt toBigInt(string nums) {
    BigInt result;
    for (int i = (int)nums.length() - 1; i >= 0; i--) {
        result.push_back(nums[i] - '0');
    }
    return result;
}

BigInt mul(BigInt a, BigInt b) {
    BigInt c = BigInt(a.size() + b.size() + 1, 0);
    for (int i = 0; i < a.size(); i++) {
        for (int j = 0; j < b.size(); j++) {
            c[i + j] += a[i] * b[j];
        }
    }
    for (int i = 0; i < a.size() + b.size(); i++) {
        if (c[i] >= 10) {
            c[i + 1] += c[i] / 10;
            c[i] = c[i] % 10;
        }
    }
    while (c.size() > 1 && c.back() == 0) {
        c.pop_back();
    }
    return c;
}

void print(BigInt a) {
    for (int i = (int)a.size() - 1; i >= 0; i--) {
        cout << a[i];
    }
}

int main() {
    string nums1, nums2;
    cin >> nums1 >> nums2;
    BigInt a = toBigInt(nums1);
    BigInt b = toBigInt(nums2);
    print(mul(a, b));
    return 0;
}

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
using namespace std;

typedef vector<int> BigInt;

BigInt toBigInt(string nums) {
    BigInt result;
    for (int i = (int)nums.length() - 1; i >= 0; i--) {
        result.push_back(nums[i] - '0');
    }
    return result;
}

BigInt div(BigInt a, int b, int &r) {
    BigInt c;
    for (int i = (int)a.size() - 1; i >= 0; i--) {
        r = r * 10 + a[i];
        c.push_back(r / b);
        r = r % b;
    }
    reverse(c.begin(), c.end());
    while (c.size() > 1 && c.back() == 0) {
        c.pop_back();
    }
    return c;
}

void print(BigInt a) {
    for (int i = (int)a.size() - 1; i >= 0; i--) {
        cout << a[i];
    }
}

int main() {
    string nums;
    int b, r = 0;
    cin >> nums >> b;
    if (b == 0) {
        cout << "undefined";
        return 0;
    }
    BigInt a = toBigInt(nums);
    BigInt q = div(a, b, r);
    print(q);
    cout << " " << r;
    return 0;
}

5.7扩展欧几里得算法

#include <cstdio>
#include <algorithm>
using namespace std;

int gcd(int a, int b) {
    if (b == 0) {
        return a;
    } else {
        return gcd(b, a % b);
    }
}

int main() {
    int a, b, c;
    scanf("%d%d%d", &a, &b, &c);
    printf(c % gcd(a, b) == 0 ? "Yes" : "No");
    return 0;
}

#include <cstdio>
#include <algorithm>
using namespace std;

int exGcd(int a, int b, int &x, int &y) {
    if (b == 0) {
        x = 1;
        y = 0;
        return a;
    }
    int d = exGcd(b, a % b, x, y);
    int temp = x;
    x = y;
    y = temp - a / b * y;
    return d;
}

int main() {
    int a, b, x, y;
    scanf("%d%d", &a, &b);
    int d = exGcd(a, b, x, y);
    int step = b / d;
    int minX = (x % step + step) % step;
    printf("%d %d", minX, (d - a * minX) / b);
    return 0;
}

#include <cstdio>
#include <algorithm>
using namespace std;

int exGcd(int a, int b, int &x, int &y) {
    if (b == 0) {
        x = 1;
        y = 0;
        return a;
    }
    int d = exGcd(b, a % b, x, y);
    int temp = x;
    x = y;
    y = temp - a / b * y;
    return d;
}

int solve(int a, int b, int c) {
    int x, y;
    int d = exGcd(a, b, x, y);
    if (c % d) {
        return -1;
    } else {
        int step = abs(b / d);
        int minX = (c * x / d % step + step) % step;
        return minX;
    }
}

int main() {
    int a, b, c;
    scanf("%d%d%d", &a, &b, &c);
    int minX = solve(a, b, c);
    if (minX == -1) {
        printf("No Solution");
    } else {
        printf("%d %d", minX, (c - a * minX) / b);
    }
    return 0;
}

#include <cstdio>
#include <algorithm>
using namespace std;

int exGcd(int a, int b, int &x, int &y) {
    if (b == 0) {
        x = 1;
        y = 0;
        return a;
    }
    int d = exGcd(b, a % b, x, y);
    int temp = x;
    x = y;
    y = temp - a / b * y;
    return d;
}

int solve(int a, int b, int c) {
    int x, y;
    int d = exGcd(a, b, x, y);
    if (c % d) {
        return -1;
    } else {
        int step = abs(b / d);
        int minX = (c * x / d % step + step) % step;
        return minX;
    }
}

int main() {
    int a, c, m, x, y;
    scanf("%d%d%d", &a, &c, &m);
    int minX = solve(a, m, c);
    if (minX == -1) {
        printf("No Solution");
    } else {
        printf("%d", minX);
    }
    return 0;
}

#include <cstdio>
#include <algorithm>
using namespace std;

int exGcd(int a, int b, int &x, int &y) {
    if (b == 0) {
        x = 1;
        y = 0;
        return a;
    }
    int d = exGcd(b, a % b, x, y);
    int temp = x;
    x = y;
    y = temp - a / b * y;
    return d;
}

int invert(int a, int m) {
    int x, y;
    int d = exGcd(a, m, x, y);
    if (d != 1) {
        return -1;
    } else {
        return (x % m + m) % m;
    }
}

int main() {
    int a, m;
    scanf("%d%d", &a, &m);
    int result = invert(a, m);
    if (result == -1) {
        printf("No Solution");
    } else {
        printf("%d", result);
    }
    return 0;
}

#include <cstdio>
#include <algorithm>
using namespace std;

int exGcd(int a, int b, int &x, int &y) {
    if (b == 0) {
        x = 1;
        y = 0;
        return a;
    }
    int d = exGcd(b, a % b, x, y);
    int temp = x;
    x = y;
    y = temp - a / b * y;
    return d;
}

int invert(int a, int m) {
    int x, y;
    int d = exGcd(a, m, x, y);
    if (d != 1) {
        return -1;
    } else {
        return (x % m + m) % m;
    }
}

int main() {
    int n, a, m, b;
    scanf("%d%d%d", &n, &a, &m);
    int result = invert(abs(a), m);
    for (int i = 0; i < n; i++) {
        scanf("%d", &b);
        result = (result * b) % m;
    }
    printf("%d", result);
    return 0;
}

5.8组合数

#include <cstdio>
int cal(int n,int p)
{
    if(n<p)return 0;
    return n/p+cal(n/p,p);

}
int main() {
    int n,p=2;
    scanf("%d", &n);
    printf("%d", cal(n,p));
    return 0;
}

#include <cstdio>

typedef long long LL;

LL C(LL n, LL m) {
    LL ans = 1;
    for (LL i = 1; i <= m; i++) {
        ans = ans * (n - m + i) / i;
    }
    return ans;
}

int main() {
    LL n, m;
    scanf("%lld%lld", &n, &m);
    printf("%lld", C(n, m));
    return 0;
}

Polaris北极星少女
关注
  • 3
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
编程算法同步入门
GitChat
05-29 6555
【读书笔记】——《自学是门手艺》By李笑来
Amazingren的博客
03-22 4839
01 Preface 一切与自学相关的技巧都是老生常谈。 因为啊，历史上留下来的所有关于自学的技巧，都是人类史上最聪明的人留下来的 —— 你我这样的人，照做就可以了…… 现在你明白怎么回事儿了吧？ 千万不要一不小心就把自己搭进去…… 02 Proof-of-work git学习之Progit: https://git-scm.com/book/zh/v2 ...
算法竞赛再入门之路——目录篇（预计）
u012681544的博客
09-17 140
算法竞赛再入门自学笔记，希望能帮到大家 0x00真正的基础 0x01基础中的进阶——深度解析各种算法竞赛中常用的编程小技巧（1.0持续更新） 0x02模拟模拟再模拟——最简单也最难（buhsi 0x03贪心问题（谁不想吃peach呢） 0x04数据结构初步 0x05搜索入门——浅谈BFS、DFS 0x06搜索登堂——解析剪枝优化 0x07搜索入室——A*以及IDA*(带有估计函数的搜 索) ## 0x08数学Part1:数论 0x09数学Part2:博弈论 0x0A数学Part2:线性代
CSAPP笔记——第二章计算机中信息的表示和处理
做一个善良的人，做好自己的事，如果愿意，再发一份光。
05-12 880
计算机中的信息存储与表示全过程、无符号整数、有符号整数的加减乘除运算等
神奇的兔子数列——算法学习笔记
m0_57158496的博客
10-23 2776
这是我参加“14天阅读挑战赛”第一周第二篇 点击查看“14天阅读挑战赛”详情，《趣学算法第二版》1.4 神奇的兔子数列。 跟着小玉老师学算法 神奇的“兔子数列” (递归、循环，哪个更好？)   假设第1个月有1对初生的兔子，第2个月进入成熟期，第3个月开始生育兔子，而1对成熟的兔子每月会生1对兔子，兔子永不死去……那么，由1对初生的兔子开始，12个月后会有多少对兔子呢？  兔子数列即斐波那契数列，它的发明者是意大利数学家莱奥纳尔多·斐波那契（Leonardo Fibonacci，1170—
小学生C++入门书籍、算法入门书籍，NOI数学书籍等
青少年趣味编程
06-10 2745
小学生C++入门书籍、算法入门书籍，NOI数学书籍等
《Unity Shader入门精要》笔记03 第3章
Tervor_HAN的博客
10-18 300
基础篇 第3章 Unity Shader基础 ——本系列是基于人民邮电出版社《Unity Shader入门精要》（冯乐乐著 ）的自学Unity Shader笔记，如果您发现了本文的纰漏，还望不吝指正。 基础篇 第1章 欢迎来到Shader的世界 第2章 渲染流水线 第3章 Unity Shader基础 第4章 学习Shader所需的数学基础 通过前面的学习内容我们已经知道，Shader并不是什么神秘的东西，它们其实就是渲染流水线中的某些特定阶段，如顶点着色器阶段、片元着色器阶段等。 Unity S
学习笔记——动态规划(全)
m0_70897036的博客
03-09 1134
递推 1.递推和动态规划有什么关系？ 递推问题包括动态规划，动态规划一定是递推，递推不一定是动态规划。 动态规划是一种决策性的问题，是在状态中做最优决策的一种特殊递推算法，通常的问法包括求最大最小值等，而递推可能还会包括求种类数等问题。 2.递推和递归的区别？ 递推是一种算法，用来解决一类特殊的问题，而递归是程序实现的形式，不属于算法范畴。 3.递推问题求解的一般过程 1.状态定义（核心环节，f[i][j]:符号表达式以及对这个表达式的文字定义） 2.确定递推公式（形如dp [ i ][ j ]=dp [
Unity游戏开发客户端面经——算法（初级）
热门推荐
Sea3752的博客
10-27 1万+
Unity游戏开发客户端面经之算法篇
hadoop3自学入门笔记(1)——虚拟机安装和网络配置
01-20
文章目录前言软件版本介绍虚拟机配置规划虚拟机的创建复制虚拟机，避免多次安装虚拟机配置ip使用 xshellSSH免密码登录关闭防火墙参考文献 前言 年过30惶惶不安，又逢疫情，还是不断学习，强化自己的能力。...
hadoop3自学入门笔记(2)—— HDFS分布式搭建
01-20
【Hadoop 3自学入门笔记(2)—— HDFS分布式搭建】 在学习Hadoop 3分布式文件系统（HDFS）的搭建过程中，首先要了解Hadoop 2与Hadoop 3的差异，特别是在端口配置方面。Hadoop 3相较于Hadoop 2在安全性、可扩展性和...
最全自学笔记，自学路线Html5+css3.mmap
09-14
Html5+css3最全自学笔记，自学路线，最快入门方法，你指的拥有
【Python入门自学笔记专辑】——面向对象编程
01-20
【Python入门自学笔记专辑】——面向对象编程 前言 ​ 面相对象是Python的重要特性，继承了C++的类风格，在Python中的一切数据类型都是面向对象的。本章主要介绍Python的面向对象编程。 面向对象： ​ 什么是OOP...
ProE Wildfire 5.0中文版完全自学视频教程下载第5章 图形造型师——草图编辑.zip
04-14
在第五章“图形造型师——草图编辑”中，我们将深入探讨ProE Wildfire 5.0在二维草图绘制与编辑方面的核心技巧。 草图编辑是ProE Wildfire 5.0中至关重要的一环，它是构建三维模型的基础。在这个章节中，你将学习到...
代码随想录算法训练营第22天-leetcode-二叉树08：669. 修剪二叉搜索树；108.将有序数组转换为二叉搜索树；538.把二叉搜索树转换为累加树
weixin_65180740的博客
07-24 947
你可能需要改变树的根节点，所以结果应当返回修剪好的二叉搜索树的新的根节点。给出二叉 搜索 树的根节点，该树的节点值各不相同，请你将其转换为累加树（Greater Sum Tree），使每个节点 node 的新值等于原树中大于或等于 node.val 的值之和。题目要求，实际上是每个节点加上中序排列后面的那个节点，故而可以反向中序排序，即RNL，用prior记录前一个节点的值，加上前一个节点的值即可。左右子树也必须是二叉搜索树。后序遍历每个节点，对于在范围外的节点，考虑保留其左子树/右子树（只可能保留一个）
算法训练营第47天|1143.最长公共子序列|1035.不相交的线|53. 最大子序和|392.判断子序列
bless_______的博客
07-24 237
如果text1[i - 1] 与 text2[j - 1]不相同，那就看看text1[0, i - 2]与text2[0, j - 1]的最长公共子序列 和 text1[0, i - 1]与text2[0, j - 2]的最长公共子序列，取最大的。如果text1[i - 1] 与 text2[j - 1]相同，那么找到了一个公共元素，所以dp[i][j] = dp[i - 1][j - 1] + 1;未想到特殊情况，即s或t为空串的情况，因为返回的是数组值，但是如果是空串就不会建立数组。
2.6基本算法之动态规划6045:开餐馆
最新发布
Andy_SCP001的博客
07-24 253
北大信息学院的同学小明毕业之后打算创业开餐馆.现在共有n 个地点可供选择。我们用一个整数序列m1, m2, ... mn 来表示他们的相对位置。由于地段关系,开餐馆的利润会有所不同。为了避免自己的餐馆的内部竞争,餐馆之间的距离必须大于k。//f[i]:从第1个位置到开第i个位置开餐馆能获得的最大利润。j++){//从j个地点到第i个地点开餐馆。//n个地点开一家店。//每个餐馆开的位置。//边界条件:只有一个地点,只开一家店。//n个地点开很多家店。
算法-KMP字符串匹配
xx_xb的博客
07-23 310
next[i] 就是使子串 s[0…i] 有最长相等前后缀的前缀的最后一位的下标。总体来说解next数组和模板串匹配的过程很相似，触类旁通。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Polaris北极星少女

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值