qiao-er

HDOJ

文章目录

#1003 Max Sum
#1004 Let the Balloon Rise
#1005 Number Sequence
#1008 Elevator
#1012 u Calculate e
#1013 Digital Roots
#1015 Safecracker
#1017 A Mathematical Curiosity
#1018 Big Number
#1019 Least Common Multiple
#1021 Fibonacci Again
#1037 Keep on Truckin'
#1342 Lotto
#1049 Climbing Worm
#1089 A+B for Input-Output Practice (I)
#1090 A+B for Input-Output Practice (II)
#1091 A+B for Input-Output Practice (III)
#1092 A+B for Input-Output Practice (IV)
#1093 A+B for Input-Output Practice (V)
#1094 A+B for Input-Output Practice (VI)
#1095 A+B for Input-Output Practice (VII)
#1096 A+B for Input-Output Practice (VIII)
#1097 A hard puzzle
#1098 Ignatius's puzzle
#1099 Lottery

#1003 Max Sum

原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=1003
解析链接：https://my.oschina.net/itblog/blog/267860

算法一（穷竭算法）

#include 
#include 

const int MAX_N = 100000;
int seq[MAX_N], T, kase = 0, first = true;

int main() {
    void resolve();
    scanf("%d", &T);
    resolve();
    return 0;
}

void resolve() {
    while (T--) {
        memset(seq, 0, sizeof(seq));

        int N, max_sum = 0, s = 0, t = 0;
        scanf("%d", &N);
        for (int i = 0; i < N; ++i)
            scanf("%d", &seq[i]);
        for (int i = 0; i < N; ++i) {
            for (int j = i; j < N; ++j) {
                int sum = 0;
                for (int k = i; k <= j; ++k)
                    sum += seq[k];
                if (sum > max_sum) {
                    max_sum = sum;
                    s = i;
                    t = j;
                }
            }
        }
        if (first)
            first = false;
        else
            printf("\n");
        printf("Case %d:\n", ++kase);
        printf("%d %d %d\n", max_sum, s + 1, t + 1);
    }
}

此算法比较简单，但时间复杂度为 $O(n^3)$ 。提交会显示超时。

算法二

for (int i = 0; i < N; ++i) {
    int sum = 0;
    for (int j = i; j < N; ++j) {
        sum += seq[j];
        if (sum > max_sum) {
            max_sum = sum;
            s = i;
            t = j;
        }
    }
}

显然，此算法时间复杂度为 $O(n^2)$ 。但提交时仍然超时。

算法三

#include 
#include 

const int MAX_N = 100000;
int seq[MAX_N], T, kase = 0, first = true;

int main() {
    void resolve();
    scanf("%d", &T);
    resolve();
    return 0;
}

void resolve() {
    while (T--) {
        memset(seq, 0, sizeof(seq));

        int N, max_sum = 0, this_sum = 0, s = 0, t = 0;
        scanf("%d", &N);
        for (int i = 0; i < N; ++i)
            scanf("%d", &seq[i]);

        // 如果全为负数
        bool all_negative = true;
        for (int i = 0; i < N; ++i) {
            if (seq[i] >= 0) all_negative = false;
        }
        if (all_negative) {
            max_sum = seq[0];
            s = 0, t = 0;
            for (int i = 1; i < N; ++i) {
                if (seq[i] > max_sum) {
                    max_sum = seq[i];
                    s = i, t = i;
                }
            }
        } else
            // 不全为负数
            for (int i = 0, j = 0; j < N; ++j) {
                this_sum += seq[j];
                if (this_sum > max_sum) {
                    max_sum = this_sum;
                    s = i;
                    t = j;
                } else if (this_sum < 0) {
                    this_sum = 0;
                    i = j + 1;
                }
            }
        if (first)
            first = false;
        else
            printf("\n");
        printf("Case %d:\n", ++kase);
        printf("%d %d %d\n", max_sum, s + 1, t + 1);
    }
}

#1004 Let the Balloon Rise

原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=1004

#include 
#include 
#include 
using namespace std;
const int MAX_N = 1005;
string colors[MAX_N];
typedef pair<string, int> BALLOON;
BALLOON B[MAX_N];

int main()
{
    void resolve();
    resolve();
    return 0;
}

void resolve()
{
    int N;

    while(cin>>N && N != 0)
    {
        int color_count = 0;
        for(int i = 0; i<N; i++)
        {
            cin>>colors[i];
            string color = colors[i];
            int j;
            for(j = 0; j<color_count; j++)
            {
                if(color == B[j].first)
                {
                    B[j].second++;
                    break;
                }
            }
            if(j>= color_count)
            {
                BALLOON b(color, 1);
                B[color_count++] = b;
            }
        }

        BALLOON popular = B[0];
        for(int i = 1; i<color_count; i++)
        {
            BALLOON b = B[i];
            if(b.second>popular.second)
            {
                popular = b;
            }
        }
        cout<<popular.first<<endl;
    }
}

#1005 Number Sequence

原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=1005

#include 
#include 
const int MAX_N = 1000;
int F[MAX_N], A, B, n;

int main(){
	void resolve();
	resolve();
	return 0;
} 

void resolve(){
	int initF();
	while(scanf("%d %d %d", &A, &B, &n) !=EOF){
		// 终止条件
		if(A == 0 && B == 0 && n ==0 ) break;
		
		memset(F, -1 , sizeof(F));
		int cycle = initF();
		int res = F[n % cycle];
		printf("%d\n", res);
	}
}

// 返回循环周期
int initF(){
	F[1] = 1,F[2] = 1;
	int i, cycle;
	for(i = 3;i<MAX_N;i++){
		F[i] = ((A *F[i-1] + B*F[i-2]) % 7);
		if(F[i] == 1 && F[i-1] == 1){
			/* ① */
			break;
		}
	}
	cycle = i-2; /* ② */
	F[0] = F[cycle];
	return cycle;
}

上面这段代码比较神秘的地方在于，如果把②处的这一行移到①处，逻辑上没有任何问题，本地也能跑通，但提交的时候会报“除0”错误。有时候不得不说，编程是一种玄学。

#1008 Elevator

原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=1008

#include
const int MAX_N = 100;
int a[MAX_N];
int N;
int main()
{
    void resolve();
    resolve();
    return 0;
}

void resolve()
{
    while(scanf("%d", &N) == 1 && N !=0)
    {
        int t = 0, current = 0;
        for(int i = 0; i< N; i++)
        {
            scanf("%d", &a[i]);
        }
        t = N * 5;
        for(int i = 0; i< N; i++)
        {
            int next = a[i];
            if(next > current)
            {
                t += ((next-current) * 6);
            }
            else if(next < current)
            {
                t += ((current-next) * 4);
            }
            current = next;
        }
        printf("%d\n", t);
    }
}

这道题有一点没有讲明白的是，如果连续多次是同一楼层，那么每一楼层是不是仍然要加5秒。但实际在提交的时候，如果你不加，是不通过的。

#1012 u Calculate e

原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=1012

#include 

int main(){
    void resolve();
    resolve();
    return 0;
}

void resolve(){
    int fac(int);
    int n = 9;
    printf("n e\n- -----------\n0 1\n1 2\n2 2.5\n");
    for(int i= 3;i<=9 ;i++){
        printf("%d ", i);
        double e = 0;
        for(int j = 0;j<=i;j++){
            e+=(1.0 / fac(j));
        }
        printf("%.9f\n", e);
    }
}

int fac(int n){
    if(n == 0) return 1;
    return n * fac(n-1);
}

这道题坑的地方在于只有前面三个不需要后面补0，而后面的全部都是小数点后9位。所以把前三个单独输出。

#1013 Digital Roots

原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=1013

#include 
#include 
const int MAX_N = 1000;
char n[MAX_N];
void resolve();
int main()
{
    resolve();
    return 0;
}

void resolve()
{
    int getRoot(int);

    while(scanf("%s", n)!=EOF)
    {
        int len = strlen(n);
        if(len == 1 && n[0]=='0')
            break;

        int sum = 0;
        for(int i = 0; i<len; i++)
        {
            sum+=n[i]-'0';
        }
        int root = getRoot(sum);
        printf("%d\n", root);
    }
}

int getRoot(int n)
{
    int sum = 0;
    while(n!=0)
    {
        sum+=n%10;
        n /= 10;
    }
    if(sum<10)
        return sum;
    else
        return getRoot(sum);
}

#1015 Safecracker

原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=1015

#include 
#include 
#include 

using namespace std;
const int MAX_N = 13;
long long target;
char letter[MAX_N];

int main() {
    void resolve();
    resolve();
    return 0;
}

bool compare(int a, int b) {
    return a > b;
}

void resolve() {
    while (scanf("%lld %s", &target, letter)) {
        // 终止条件
        if (target == 0 && strcmp(letter, "END") == 0)break;

        int len = strlen(letter);

        sort(letter, letter + len, compare);
        bool ok = false;

        for (int i = 0; i < len; ++i) {
            for (int j = 0; j < len; ++j) {
                if (j == i) continue;
                for (int k = 0; k < len; ++k) {
                    if (k == j || k == i) continue;
                    for (int l = 0; l < len; ++l) {
                        if (l == i || l == j || l == k) continue;
                        for (int m = 0; m < len; ++m) {
                            if (m == i || m == j || m == k || m == l) continue;

                            int v = letter[i] - 'A' + 1;
                            int w = letter[j] - 'A' + 1;
                            int x = letter[k] - 'A' + 1;
                            int y = letter[l] - 'A' + 1;
                            int z = letter[m] - 'A' + 1;
                            long long res = (long long) (v - w * w + x * x * x - y * y * y * y + z * z * z * z * z);
                            if (target == res) {
                                printf("%c%c%c%c%c\n", letter[i], letter[j], letter[k], letter[l], letter[m]);
                                ok = true;
                                break;
                            }
                        }
                        if (ok) break;
                    }
                    if (ok) true;
                }
                if (ok) true;
            }
            if (ok) true;
        }
        if (!ok) printf("no solution\n");
    }
}

首先要降序排序。注意，这里不能使用pow函数求次方，会出现精度问题。还有，这道题没有说明白一点，就是各个字母不能重复出现。

#1017 A Mathematical Curiosity

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1017

#include 
#include 

int N;

void resolve();

int main() {
    scanf("%d", &N);
    resolve();
    return 0;
}

void resolve() {
    bool first = true;
    while (N--) {
        int n, m;
        int kase = 0;
        if (first)
            first = false;
        else
            printf("\n");
        while (scanf("%d%d", &n, &m) == 2) {
            if (!n && !m)break;
            int count = 0;
            for (int a = 1; a < n; ++a) {
                for (int b = a + 1; b < n; ++b) {
                    int Z = a * a + b * b + m;
                    int M = a * b;
                    if (Z % M == 0)
                        count++;
                }
            }
            printf("Case %d: %d\n", ++kase, count);
        }
    }
}

#1018 Big Number

原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=1018
解析链接：https://blog.csdn.net/courtneygeng/article/details/9897149

#include 
#include 

void resolve();

int main() {
    resolve();
    return 0;
}

void resolve() {
    int n;
    scanf("%d", &n);
    for (int i = 0; i < n; ++i) {
        int num;
        scanf("%d", &num);
        double sum = 0;
        for (int j = 1; j <= num; ++j) {
            sum += log10(j);
        }
        int res = (int) sum + 1;
        printf("%d\n", res);
    }
}

任意一个正整数a的位数等于 $\lfloor log_{10}a \rfloor + 1$ 。任意阶乘 $\cdot 2 \cdot 3 \cdot \cdots \cdot n$ ，其位数为 $\lfloor log_{10}1 + log_{10}2 + log_{10}3 + \cdots + log_{10}n\rfloor + 1$ 。

#1019 Least Common Multiple

原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=1019

#include 
#include 

using namespace std;

int N;
const int MAX_M = 10000;
int nums[MAX_M];

void resolve();

int gcd(int, int);

int lcm(int, int);

int main() {
    scanf("%d", &N);
    resolve();
    return 0;
}

void resolve() {
    while (N--) {
        int m;
        scanf("%d", &m);
        for (int i = 0; i < m; ++i)
            scanf("%d", &nums[i]);
        int a = nums[0];
        for (int j = 1; j < m; ++j) {
            int LCM = lcm(a, nums[j]);
            a = LCM;
        }
        cout << a << endl;
    }
}

int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}

int lcm(int a, int b) {
    if (a < b) {
        int tmp = a;
        a = b;
        b = tmp;
    }
    return a / gcd(a, b) * b;
}

#1021 Fibonacci Again

#include 
#include 

using namespace std;

void resolve();

int main() {
    resolve();
    return 0;
}

void resolve() {
    int n;
    while (scanf("%d", &n) != EOF) {
        if (n % 4 == 2)
            cout << "yes" << endl;
        else
            cout << "no" << endl;
    }
}

#1037 Keep on Truckin’

原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=1037

#include 

int set[3];

int main() {
    void resolve();
    for (int i = 0; i < 3; ++i) {
        scanf("%d", &set[i]);
    }
    resolve();
    return 0;
}

void resolve() {
    bool crash = false;
    for (int i = 0; i < 3; ++i) {
        if (set[i] <= 168) {
            crash = true;
            printf("CRASH %d\n", set[i]);
            break;
        }
    }
    if (!crash) printf("NO CRASH\n");
}

#1342 Lotto

原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=1342
解析链接：https://blog.csdn.net/pengwill97/article/details/54850852

#include 

const int MAX_N = 13;
int ans[6], S[MAX_N], k;

int main() {
    void resolve();
    resolve();
    return 0;
}

void resolve() {
    void dfs(int, int);
    bool first = true;
    while (scanf("%d", &k) && k != 0) {
        for (int i = 0; i < k; ++i) {
            scanf("%d", &S[i]);
        }
        if (first)first = false;
        else printf("\n");

        dfs(0, 0);
    }
}

void dfs(int i, int j) { // i表示ans数组的索引，j表示S数组的索引
    void print_ans();
    if (i >= 6) {
        print_ans();
        return;
    }
    if (j >= k) return;
    ans[i] = S[j];
    dfs(i + 1, j + 1);
    dfs(i, j + 1);
}

void print_ans() {
    printf("%d", ans[0]);
    for (int l = 1; l < 6; ++l) {
        printf(" %d", ans[l]);
    }
    printf("\n");
}

#1049 Climbing Worm

原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=1049

#include 

int n, u, d;

int main() {
    void resolve();

    resolve();
    return 0;
}

void resolve() {
    while (scanf("%d%d%d", &n, &u, &d)) {
        if (!n && !u && !d) break;
        int cur_height = 0, time = 0;
        bool climb = true;
        while (cur_height < n) {
            if (climb)
                cur_height += u;
            else
                cur_height -= d;
            climb = !climb;
            time++;
        }
        printf("%d\n", time);
    }
}

#1089 A+B for Input-Output Practice (I)

原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=1089

#include 

int main() {
    void resolve();

    resolve();
}

void resolve() {
    int a, b;
    while (scanf("%d%d", &a, &b) != EOF) {
        printf("%d\n", a + b);
    }
}

#1090 A+B for Input-Output Practice (II)

原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=1090

#include 

int main() {
    void resolve();

    resolve();
}

void resolve() {
    int a, b, n;
    scanf("%d", &n);
    for (int i = 0; i < n; ++i) {
        scanf("%d%d", &a, &b);
        printf("%d\n", a + b);
    }
}

#1091 A+B for Input-Output Practice (III)

原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=1091

#include 

int main() {
    void resolve();

    resolve();
}

void resolve() {
    int a, b;
    while (scanf("%d%d", &a, &b) != EOF) {
        if (!a && !b) break;
        printf("%d\n", a + b);
    }
}

#1092 A+B for Input-Output Practice (IV)

原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=1092

#include 

int main() {
    void resolve();

    resolve();
    return 0;
}

void resolve() {
    int n, sum, tmp;
    while (scanf("%d", &n)) {
        if (!n) break;
        sum = 0;
        for (int i = 0; i < n; ++i) {
            scanf("%d", &tmp);
            sum += tmp;
        }
        printf("%d\n", sum);
    }
}

#1093 A+B for Input-Output Practice (V)

原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=1093

#include 

int N;

int main() {
    void resolve();
    resolve();
    return 0;
}

void resolve() {
    scanf("%d", &N);
    for (int i = 0; i < N; ++i) {
        int M, sum = 0, tmp;
        scanf("%d", &M);
        for (int j = 0; j < M; ++j) {
            scanf("%d", &tmp);
            sum += tmp;
        }
        printf("%d\n", sum);
    }
}

#1094 A+B for Input-Output Practice (VI)

原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=1094

#include 

int main() {
    void resolve();
    resolve();
    return 0;
}

void resolve() {
    int N, sum, tmp;
    while (scanf("%d", &N) != EOF) {
        sum = 0;
        for (int i = 0; i < N; ++i) {
            scanf("%d", &tmp);
            sum += tmp;
        }
        printf("%d\n", sum);
    }
}

#1095 A+B for Input-Output Practice (VII)

原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=1095

#include 

int main() {
    void resolve();
    resolve();
    return 0;
}

void resolve() {
    int a, b;
    while (scanf("%d%d", &a, &b) != EOF) {
        printf("%d\n\n", a + b);
    }
}

#1096 A+B for Input-Output Practice (VIII)

原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=1096

#include 

int main() {
    void resolve();
    resolve();
    return 0;
}

void resolve() {
    int N, M, sum, tmp;
    bool first = true;
    scanf("%d", &N);
    for (int i = 0; i < N; ++i) {
        scanf("%d", &M);
        sum = 0;
        for (int j = 0; j < M; ++j) {
            scanf("%d", &tmp);
            sum += tmp;
        }
        if (first) {
            first = false;
        } else {
            printf("\n");
        }
        printf("%d\n", sum);
    }
}

#1097 A hard puzzle

原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=1097

#include 
#include 

int main() {
    void resolve();
    resolve();
    return 0;
}

void resolve() {
    long long a, b;
    int digit[10]; // 存放个位数的数组，最多不超过10个：0~9
    while (scanf("%lld%lld", &a, &b) != EOF) {
        int last = (int) a % 10; // a的个位数
        int res = 1;
        memset(digit, -1, sizeof(digit));
        int digit_len = 0; // digit数组实际的元素个数
        for (int i = 0; i < b; ++i) {
            res *= last;
            res %= 10;

            // 查找新的个位数在不在digit数组中
            bool exit = false;
            for (int j = 0; j < digit_len; ++j) {
                if (res == digit[j]) { // 如果某个数已经在digit中，说明已经产生了一个循环，则退出
                    exit = true;
                    break;
                }
            }
            if (!exit) digit[digit_len++] = res; // 某个数不在digit中，则加入digit中
            if (exit)break;
        }

        int pos = (int) (b % digit_len);
        if (pos == 0) pos = digit_len - 1;
        else pos -= 1;
        printf("%d\n", digit[pos]);
    }
}

#1098 Ignatius’s puzzle

原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=1098

#include 

int main() {
    void resolve();
    resolve();
    return 0;
}

void resolve() {
    int k;
    while (scanf("%d", &k) != EOF) {
        int a;
        for (a = 1; a < 10000; ++a) {
            if ((18 + k * a) % 65 == 0) {
                printf("%d\n", a);
                break;
            }
        }
        if (a >= 10000) {
            printf("no\n");
        }
    }
}

由于对于任何的x都成立，取x=1，得 18+ka 。即只要(18+ka)%65 == 0即可。详细的证明可参考：https://blog.csdn.net/u014355480/article/details/44248493。在这里，由题意可知k<10000，而a与k的身份相同，均为因式，可认为a<10000，故for循环的条件是a < 10000 。

#1099 Lottery

原题链接：http://acm.hdu.edu.cn/showproblem.php?pid=1099

#include 

typedef long long LL;

LL gcd(LL, LL);

LL lcm(LL, LL);

int digits(LL);

int main() {
    void resolve();
    resolve();
    return 0;
}

void resolve() {
    int n;
    while (scanf("%d", &n) != EOF) {
        LL z = 1, m = 1, integer = 0; // z分子, m分母, integer表示带分数的整数部分
        LL g; // 求最大公约数的临时变量
        for (int i = 2; i <= n; ++i) {
            LL old_m = m;
            m = lcm(m, i); // 分母
            z = z * (m / old_m) + (m / i); // 分子
        }
        z *= n;
        g = gcd(m, z);
        z /= g;
        m /= g;
        if (z % m == 0) { // 能整除
            printf("%lld\n", z / m);
        } else { // 不能整除，带分数
            integer = z / m;
            z %= m;

            for (int i = 0; i < digits(integer); ++i)
                printf(" ");
            printf(" %lld\n", z);
            printf("%lld ", integer);
            for (int i = 0; i < digits(m); ++i)
                printf("-");
            printf("\n");
            for (int i = 0; i < digits(integer); ++i)
                printf(" ");
            printf(" %lld\n", m);
        }
    }
}

// 最大公约数
LL gcd(LL a, LL b) {
    if (a == 0) return b;
    return gcd(b % a, a);
}

// 最小公倍数
LL lcm(LL a, LL b) {
    return a * b / gcd(a, b);
}

// 求一个数字的位数
int digits(LL number) {
    int i = 0;
    while (number > 0) {
        number /= 10;
        i++;
    }
    return i;
}

问题转化为求 $n(\frac{1}{1}+\frac{1}{2}+\frac{1}{3}+\cdots+\frac{1}{n-1}+\frac{1}{n})$
要注意，这里求最大公约数要用辗转相除法，直接使用遍历求最大公约数会超时。

机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习 python
一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
Goolge earth studio 进阶4——路径修改与平滑陟彼高冈yu Google earth studio 进阶教程旅游
如果我们希望在大约中途时获得更多的城市鸟瞰视角。可以将相机拖动到这里并创建一个新的关键帧。camera_target_clip_7EarthStudio会自动平滑我们的路径，所以当我们通过这个关键帧时，不是一个生硬的角度，而是一个平滑的曲线。camera_target_clip_8路径上有贝塞尔控制手柄，允许我们调整路径的形状。右键单击，我们可以选择“平滑路径”，这是默认的自动平滑算法，或者我们可
基于社交网络算法优化的二维最大熵图像分割智能算法研学社（Jack旭）智能优化算法应用图像分割算法 php 开发语言
智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码文章目录智能优化算法应用：基于社交网络优化的二维最大熵图像阈值分割-附代码1.前言2.二维最大熵阈值分割原理3.基于社交网络优化的多阈值分割4.算法结果：5.参考文献：6.Matlab代码摘要：本文介绍基于最大熵的图像分割，并且应用社交网络算法进行阈值寻优。1.前言阅读此文章前，请阅读《图像分割：直方图区域划分及信息统计介绍》htt
121. 买卖股票的最佳时机薄荷糖的味道_fb40
给定一个数组，它的第i个元素是一支给定股票第i天的价格。如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。注意你不能在买入股票前卖出股票。示例1:输入:[7,1,5,3,6,4]输出:5解释:在第2天（股票价格=1）的时候买入，在第5天（股票价格=6）的时候卖出，最大利润=6-1=5。注意利润不能是7-1=6,因为卖出价格需要大于买入价格。示例2:输入:
每日算法&面试题，大厂特训二十八天——第二十天（树）肥学 ⚡算法题⚡面试题每日精进 java 算法数据结构
目录标题导读算法特训二十八天面试题点击直接资料领取导读肥友们为了更好的去帮助新同学适应算法和面试题，最近我们开始进行专项突击一步一步来。上一期我们完成了动态规划二十一天现在我们进行下一项对各类算法进行二十八天的一个小总结。还在等什么快来一起肥学进行二十八天挑战吧！！特别介绍小白练手专栏，适合刚入手的新人欢迎订阅编程小白进阶python有趣练手项目里面包括了像《机器人尬聊》《恶搞程序》这样的有趣文章
回溯算法-重新安排行程 chirou_ 算法数据结构图论 c++图搜索
leetcode332.重新安排行程这题我还没自己ac过，只能现在凭着刚学完的热乎劲把我对题解的理解记下来。本题我认为对数据结构的考察比较多，用什么数据结构去存数据，去读取数据，都是很重要的。classSolution{private:unordered_map>targets;boolbacktracking(intticketNum,vector&result){//1.确定参数和返回值//2
Faiss：高效相似性搜索与聚类的利器网络·魚大数据 faiss
Faiss是一个针对大规模向量集合的相似性搜索库，由FacebookAIResearch开发。它提供了一系列高效的算法和数据结构，用于加速向量之间的相似性搜索，特别是在大规模数据集上。本文将介绍Faiss的原理、核心功能以及如何在实际项目中使用它。Faiss原理：近似最近邻搜索：Faiss的核心功能之一是近似最近邻搜索，它能够高效地在大规模数据集中找到与给定查询向量最相似的向量。这种搜索是近似的，
insert into select 主键自增_mybatis拦截器实现主键自动生成 weixin_39521651 insert into select 主键自增 mybatis delete返回值 mybatis insert返回主键 mybatis insert返回对象 mybatis plus insert返回主键 mybatis plus 插入生成id
前言前阵子和朋友聊天，他说他们项目有个需求，要实现主键自动生成，不想每次新增的时候，都手动设置主键。于是我就问他，那你们数据库表设置主键自动递增不就得了。他的回答是他们项目目前的id都是采用雪花算法来生成，因此为了项目稳定性，不会切换id的生成方式。朋友问我有没有什么实现思路，他们公司的orm框架是mybatis，我就建议他说，不然让你老大把mybatis切换成mybatis-plus。mybat
k均值聚类算法考试例题_k均值算法(k均值聚类算法计算题) 寻找你83497 k均值聚类算法考试例题
?算法：第一步：选K个初始聚类中心，z1(1),z2(1)，…，zK(1)，其中括号内的序号为寻找聚类中心的迭代运算的次序号。聚类中心的向量值可任意设定，例如可选开始的K个.k均值聚类：---------一种硬聚类算法，隶属度只有两个取值0或1，提出的基本根据是“类内误差平方和最小化”准则；模糊的c均值聚类算法：--------一种模糊聚类算法，是.K均值聚类算法是先随机选取K个对象作为初始的聚类
Python实现简单的机器学习算法 master_chenchengg python python 办公效率 python开发 IT
Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
推荐算法_隐语义-梯度下降 _feivirus_ 算法机器学习和数学推荐算法机器学习隐语义
importnumpyasnp1.模型实现"""inputrate_matrix:M行N列的评分矩阵，值为P*Q.P:初始化用户特征矩阵M*K.Q:初始化物品特征矩阵K*N.latent_feature_cnt:隐特征的向量个数max_iteration:最大迭代次数alpha:步长lamda:正则化系数output分解之后的P和Q"""defLFM_grad_desc(rate_matrix,l
K近邻算法_分类鸢尾花数据集 _feivirus_ 算法机器学习和数学分类机器学习 K近邻
importnumpyasnpimportpandasaspdfromsklearn.datasetsimportload_irisfromsklearn.model_selectionimporttrain_test_splitfromsklearn.metricsimportaccuracy_score1.数据预处理iris=load_iris()df=pd.DataFrame(data=ir
数据结构 | 栈和队列 TT-Kun 数据结构与算法数据结构栈队列 C语言
文章目录栈和队列1.栈：后进先出（LIFO）的数据结构1.1概念与结构1.2栈的实现2.队列：先进先出（FIFO）的数据结构2.1概念与结构2.2队列的实现3.栈和队列算法题3.1有效的括号3.2用队列实现栈3.3用栈实现队列3.4设计循环队列结论栈和队列在计算机科学中，栈和队列是两种基本且重要的数据结构，它们在处理数据存储和访问顺序方面有着独特的规则和应用。本文将详细介绍栈和队列的概念、结构、实
[Python] 数据结构详解及代码 AIAdvocate 算法 python 数据结构链表
今日内容大纲介绍数据结构介绍列表链表1.数据结构和算法简介程序大白话翻译,程序=数据结构+算法数据结构指的是存储,组织数据的方式.算法指的是为了解决实际业务问题而思考思路和方法,就叫:算法.2.算法的5大特性介绍算法具有独立性算法是解决问题的思路和方式,最重要的是思维,而不是语言,其(算法)可以通过多种语言进行演绎.5大特性有输入,需要传入1或者多个参数有输出,需要返回1个或者多个结果有穷性,执行
Python算法L5：贪心算法小熊同学哦 Python算法算法 python 贪心算法
Python贪心算法简介目录Python贪心算法简介贪心算法的基本步骤贪心算法的适用场景经典贪心算法问题1.**零钱兑换问题**2.**区间调度问题**3.**背包问题**贪心算法的优缺点优点：缺点：结语贪心算法（GreedyAlgorithm）是一种在每一步选择中都采取当前最优或最优解的算法。它的核心思想是，在保证每一步局部最优的情况下，希望通过贪心选择达到全局最优解。虽然贪心算法并不总能得到全
【RabbitMQ 项目】服务端：数据管理模块之绑定管理月夜星辉雪 rabbitmq 分布式
文章目录一.编写思路二.代码实践一.编写思路定义绑定信息类交换机名称队列名称绑定关键字：交换机的路由交换算法中会用到没有是否持久化的标志，因为绑定是否持久化取决于交换机和队列是否持久化，只有它们都持久化时绑定才需要持久化。绑定就好像一根绳子，两端连接着交换机和队列，当一方不存在，它就没有存在的必要了定义绑定持久化类构造函数：如果数据库文件不存在则创建，打开数据库，创建binding_table插入
非对称加密算法原理与应用2——RSA私钥加密文件私语茶馆云部署与开发架构及产品灵感记录 RSA2048 私钥加密
作者：私语茶馆1.相关章节（1）非对称加密算法原理与应用1——秘钥的生成-CSDN博客第一章节讲述的是创建秘钥对，并将公钥和私钥导出为文件格式存储。本章节继续讲如何利用私钥加密内容，包括从密钥库或文件中读取私钥，并用RSA算法加密文件和String。2.私钥加密的概述本文主要基于第一章节的RSA2048bit的非对称加密算法讲述如何利用私钥加密文件。这种加密后的文件，只能由该私钥对应的公钥来解密。
粒子群优化 (PSO) 在三维正弦波函数中的应用 subject625Ruben 机器学习人工智能 matlab 算法
在这篇博客中，我们将展示如何使用粒子群优化（PSO）算法求解三维正弦波函数，并通过增加正弦波扰动，使优化过程更加复杂和有趣。本文将介绍目标函数的定义、PSO参数设置以及算法执行的详细过程，并展示搜索空间中的动态过程和收敛曲线。1.目标函数定义我们使用的目标函数是一个三维正弦波函数，定义如下：objectiveFunc=@(x)sin(sqrt(x(1).^2+x(2).^2))+0.5*sin(5
非对称加密算法————RSA理论及详情 hu19930613
转自：https://www.kancloud.cn/kancloud/rsa_algorithm/48484一、一点历史1976年以前，所有的加密方法都是同一种模式：（1）甲方选择某一种加密规则，对信息进行加密；（2）乙方使用同一种规则，对信息进行解密。由于加密和解密使用同样规则（简称"密钥"），这被称为"对称加密算法"（Symmetric-keyalgorithm）。这种加密模式有一个最大弱点
ai绘画工具midjourney怎么下载？附作品管理教程设计师早上好
Midjourney是一款功能强大的AI绘画工具，它使用机器学习技术和深度神经网络等算法，可以生成各种艺术风格的绘画作品。在创意设计、广告宣传等方面有着广泛的应用前景。那么，ai绘画工具midjourney怎么下载？本文将为您介绍Midjourney的下载以及作品的相关管理。一、Midjourney下载Midjourney的下载非常简单，只需打开Midjourney官网（点击“GetMidjour
【加密算法基础——对称加密和非对称加密】 XWWW668899 网络安全服务器笔记
对称加密与非对称加密对称加密和非对称加密是两种基本的加密方法，各自有不同的特点和用途。以下是详细比较：1.对称加密特点密钥:使用相同的密钥进行加密和解密。发送方和接收方必须共享这个密钥。速度:通常速度较快，适合处理大量数据。实现:算法相对简单，计算效率高。常见算法AES(高级加密标准)DES(数据加密标准)3DES(三重数据加密标准)RC4(流密码)应用场景文件加密磁盘加密传输大量数据时的加密2.
【算法练习】IDEA集成leetcode插件实现快速刷 2401_84102892 2024年程序员学习算法 intellij-idea leetcode
============点击右侧边leetcode->设置->配置地址、用户名、密码、存放目录、文件模板用户名要登录后在账号信息里看模板代码1.codefilename!velocityTool.camelC
【加密算法基础——RSA 加密】 XWWW668899 网络服务器笔记 python
RSA加密RSA（Rivest-Shamir-Adleman）加密是非对称加密，一种广泛使用的公钥加密算法，主要用于安全数据传输。公钥用于加密，私钥用于解密。RSA加密算法的名称来源于其三位发明者的姓氏：R:RonRivestS:AdiShamirA:LeonardAdleman这三位计算机科学家在1977年共同提出了这一算法，并发表了相关论文。他们的工作为公钥加密的基础奠定了重要基础，使得安全通
机器学习-聚类算法不良人龍木木机器学习机器学习算法聚类
机器学习-聚类算法1.AHC2.K-means3.SC4.MCL仅个人笔记，感谢点赞关注！1.AHC2.K-means3.SC传统谱聚类：个人对谱聚类算法的理解以及改进4.MCL目前仅专注于NLP的技术学习和分享感谢大家的关注与支持！
生成式地图制图 Bwywb_3 深度学习机器学习深度学习生成对抗网络
生成式地图制图（GenerativeCartography）是一种利用生成式算法和人工智能技术自动创建地图的技术。它结合了传统的地理信息系统（GIS）技术与现代生成模型（如深度学习、GANs等），能够根据输入的数据自动生成符合需求的地图。这种方法在城市规划、虚拟环境设计、游戏开发等多个领域具有应用前景。主要特点：自动化生成：通过算法和模型，系统能够根据输入的地理或空间数据自动生成地图，而无需人工逐
高性能javascript--算法和流程控制海淀萌狗
-for,while和do-while性能相当-避免使用for-in循环，==除非遍历一个属性量未知的对象==es5:for-in遍历的对象便不局限于数组，还可以遍历对象。原因：for-in每次迭代操作会同时搜索实例或者原型属性，for-in循环的每次迭代都会产生更多开销，因此要比其他循环类型慢，一般速度为其他类型循环的1/7。因此，除非明确需要迭代一个属性数量未知的对象，否则应避免使用for-i
深度 Qlearning：在直播推荐系统中的应用 AGI通用人工智能之禅程序员提升自我硅基计算碳基计算认知计算生物计算深度学习神经网络大数据 AIGC AGI LLM Java Python 架构设计 Agent 程序员实现财富自由
深度Q-learning：在直播推荐系统中的应用关键词：深度Q-learning,强化学习,直播推荐系统,个性化推荐1.背景介绍1.1问题的由来随着互联网技术的飞速发展,直播平台如雨后春笋般涌现。面对海量的直播内容,用户很难快速找到自己感兴趣的内容。因此,个性化推荐系统在直播平台中扮演着越来越重要的角色。1.2研究现状目前,主流的个性化推荐算法包括协同过滤、基于内容的推荐等。这些方法在一定程度上缓
JVM源码分析之堆外内存完全解读 HeapDump性能社区
概述广义的堆外内存说到堆外内存，那大家肯定想到堆内内存，这也是我们大家接触最多的，我们在jvm参数里通常设置-Xmx来指定我们的堆的最大值，不过这还不是我们理解的Java堆，-Xmx的值是新生代和老生代的和的最大值，我们在jvm参数里通常还会加一个参数-XX:MaxPermSize来指定持久代的最大值，那么我们认识的Java堆的最大值其实是-Xmx和-XX:MaxPermSize的总和，在分代算法
《算法》四学习——1.1节进阶的Farmer 算法算法笔记
前言买了一本算法4，每天看一点，对每个小结来个学习总结，输出驱动输入。本篇笔记针对第一章基础1.1基础编程模型1.1节总结了相关的语法、语言特性和书中将会用到的库。笔记自己在编码中容易遗漏的点&&优先级比||高在开发中习惯了加括号，所以没注意到这点，教材上也有但是忘记了二分查找中计算mid=left+(right-left)/2这样计算可以有效避免(left+right)/2溢出答疑java无穷大
排序路小白同学
1.冒泡排序冒泡算法是一种基础的排序算法，这种算法会重复的比较数组中相邻的两个元素。如果一个元素比另一个元素大（小），那么就交换这两个元素的位置。重复这一比较直至最后一个元素。这一比较会重复n-1趟，每一趟比较n-j次，j是已经排序好的元素个数。每一趟比较都能找出未排序元素中最大或者最小的那个数字。这就如同水泡从水底逐个飘到水面一样。冒泡排序是一种时间复杂度较高，效率较低的排序方法。其空间复杂度是
面向对象面向过程 3213213333332132 java
面向对象：把要完成的一件事，通过对象间的协作实现。面向过程：把要完成的一件事，通过循序依次调用各个模块实现。我把大象装进冰箱这件事为例，用面向对象和面向过程实现，都是用java代码完成。 1、面向对象 package bigDemo.ObjectOriented; /** * 大象类 * * @Description * @author FuJian
Java Hotspot: Remove the Permanent Generation bookjovi HotSpot
openjdk上关于hotspot将移除永久带的描述非常详细，http://openjdk.java.net/jeps/122 JEP 122: Remove the Permanent Generation Author Jon Masamitsu Organization Oracle Created 2010/8/15 Updated 2011/
正则表达式向前查找向后查找,环绕或零宽断言 dcj3sjt126com 正则表达式
向前查找和向后查找 1. 向前查找：根据要匹配的字符序列后面存在一个特定的字符序列(肯定式向前查找)或不存在一个特定的序列(否定式向前查找)来决定是否匹配。.NET将向前查找称之为零宽度向前查找断言。对于向前查找，出现在指定项之后的字符序列不会被正则表达式引擎返回。 2. 向后查找：一个要匹配的字符序列前面有或者没有指定的
BaseDao 171815164 seda
import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; import java.sql.PreparedStatement; import java.sql.ResultSet; public class BaseDao { public Conn
Ant标签详解--Java命令 g21121 Java命令
这一篇主要介绍与java相关标签的使用终于开始重头戏了，Java部分是我们关注的重点也是项目中用处最多的部分。 1
[简单]代码片段_电梯数字排列 53873039oycg 代码
今天看电梯数字排列是9 18 26这样呈倒N排列的,写了个类似的打印例子，如下: import java.util.Arrays; public class 电梯数字排列_S3_Test { public static void main(S
Hessian原理云端月影 hessian原理
Hessian 原理分析一．远程通讯协议的基本原理网络通信需要做的就是将流从一台计算机传输到另外一台计算机，基于传输协议和网络 IO 来实现，其中传输协议比较出名的有 http 、 tcp 、 udp 等等， http 、 tcp 、 udp 都是在基于 Socket 概念上为某类应用场景而扩展出的传输协
区分Activity的四种加载模式----以及Intent的setFlags aijuans android
在多Activity开发中，有可能是自己应用之间的Activity跳转，或者夹带其他应用的可复用Activity。可能会希望跳转到原来某个Activity实例，而不是产生大量重复的Activity。这需要为Activity配置特定的加载模式，而不是使用默认的加载模式。加载模式分类及在哪里配置 Activity有四种加载模式： standard singleTop
hibernate几个核心API及其查询分析 antonyup_2006 html .net Hibernate xml 配置管理
(一) org.hibernate.cfg.Configuration类读取配置文件并创建唯一的SessionFactory对象.(一般,程序初始化hibernate时创建.) Configuration co
PL/SQL的流程控制百合不是茶 oracle PL/SQL编程循环控制
PL/SQL也是一门高级语言,所以流程控制是必须要有的,oracle数据库的pl/sql比sqlserver数据库要难,很多pl/sql中有的sqlserver里面没有流程控制; 分支语句 if 条件 then 结果 else 结果 end if ; 条件语句 case when 条件 then 结果; 循环语句 loop
强大的Mockito测试框架 bijian1013 mockito 单元测试
一.自动生成Mock类在需要Mock的属性上标记@Mock注解，然后@RunWith中配置Mockito的TestRunner或者在setUp()方法中显示调用MockitoAnnotations.initMocks(this);生成Mock类即可。二.自动注入Mock类到被测试类 &nbs
精通Oracle10编程SQL(11)开发子程序 bijian1013 oracle 数据库 plsql
/* *开发子程序 */ --子程序目是指被命名的PL/SQL块，这种块可以带有参数，可以在不同应用程序中多次调用 --PL/SQL有两种类型的子程序：过程和函数 --开发过程 --建立过程：不带任何参数 CREATE OR REPLACE PROCEDURE out_time IS BEGIN DBMS_OUTPUT.put_line(systimestamp); E
【EhCache一】EhCache版Hello World bit1129 Hello world
本篇是EhCache系列的第一篇，总体介绍使用EhCache缓存进行CRUD的API的基本使用，更细节的内容包括EhCache源代码和设计、实现原理在接下来的文章中进行介绍环境准备 1.新建Maven项目 2.添加EhCache的Maven依赖 <dependency> <groupId>ne
学习EJB3基础知识笔记白糖_ bean Hibernate jboss webservice ejb
最近项目进入系统测试阶段，全赖袁大虾领导有力，保持一周零bug记录，这也让自己腾出不少时间补充知识。花了两天时间把“传智播客EJB3.0”看完了，EJB基本的知识也有些了解，在这记录下EJB的部分知识，以供自己以后复习使用。 EJB是sun的服务器端组件模型，最大的用处是部署分布式应用程序。EJB (Enterprise JavaBean)是J2EE的一部分，定义了一个用于开发基
angular.bootstrap boyitech AngularJS AngularJS API angular中文api
angular.bootstrap 描述：手动初始化angular。这个函数会自动检测创建的module有没有被加载多次，如果有则会在浏览器的控制台打出警告日志，并且不会再次加载。这样可以避免在程序运行过程中许多奇怪的问题发生。使用方法： angular .
java-谷歌面试题-给定一个固定长度的数组，将递增整数序列写入这个数组。当写到数组尾部时，返回数组开始重新写，并覆盖先前写过的数 bylijinnan java
public class SearchInShiftedArray { /** * 题目：给定一个固定长度的数组，将递增整数序列写入这个数组。当写到数组尾部时，返回数组开始重新写，并覆盖先前写过的数。 * 请在这个特殊数组中找出给定的整数。 * 解答： * 其实就是“旋转数组”。旋转数组的最小元素见http://bylijinnan.iteye.com/bl
天使还是魔鬼？都是我们制造 ducklsl 生活教育情感
----------------------------剧透请原谅，有兴趣的朋友可以自己看看电影，互相讨论哦！！！从厦门回来的动车上，无意中瞟到了书中推荐的几部关于儿童的电影。当然，这几部电影可能会另大家失望，并不是类似小鬼当家的电影，而是关于“坏小孩”的电影！自己挑了两部先看了看，但是发现看完之后，心里久久不能平
[机器智能与生物]研究生物智能的问题 comsci 生物
我想,人的神经网络和苍蝇的神经网络,并没有本质的区别...就是大规模拓扑系统和中小规模拓扑分析的区别.... 但是,如果去研究活体人类的神经网络和脑系统,可能会受到一些法律和道德方面的限制,而且研究结果也不一定可靠,那么希望从事生物神经网络研究的朋友,不如把
获取Android Device的信息 dai_lm android
String phoneInfo = "PRODUCT: " + android.os.Build.PRODUCT; phoneInfo += ", CPU_ABI: " + android.os.Build.CPU_ABI; phoneInfo += ", TAGS: " + android.os.Build.TAGS; ph
最佳字符串匹配算法（Damerau-Levenshtein距离算法）的Java实现 datamachine java 算法字符串匹配
原文：http://www.javacodegeeks.com/2013/11/java-implementation-of-optimal-string-alignment.html------------------------------------------------------------------------------------------------------------
小学5年级英语单词背诵第一课 dcj3sjt126com english word
long 长的 show 给...看，出示 mouth 口，嘴 write 写 use 用，使用 take 拿，带来 hand 手 clever 聪明的 often 经常 wash 洗 slow 慢的 house 房子 water 水 clean 清洁的 supper 晚餐 out 在外 face 脸，
macvim的使用实战 dcj3sjt126com mac vim
macvim用的是mac里面的vim, 只不过是一个GUI的APP, 相当于一个壳 1. 下载macvim https://code.google.com/p/macvim/ 2. 了解macvim :h vim的使用帮助信息 :h macvim
java二分法查找蕃薯耀 java二分法查找二分法 java二分法
java二分法查找 >>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>> 蕃薯耀 2015年6月23日 11:40:03 星期二 http:/
Spring Cache注解+Memcached hanqunfeng spring memcached
Spring3.1 Cache注解依赖jar包：  <dependency> <groupId>com.google.code.simple-spring-memcached</groupId> <artifactId>simple-s
apache commons io包快速入门 jackyrong apache commons
原文参考 http://www.javacodegeeks.com/2014/10/apache-commons-io-tutorial.html Apache Commons IO 包绝对是好东西，地址在http://commons.apache.org/proper/commons-io/，下面用例子分别介绍： 1）工具类 2
如何学习编程 lampcy java 编程 C++c
首先,我想说一下学习思想.学编程其实跟网络游戏有着类似的效果.开始的时候,你会对那些代码,函数等产生很大的兴趣,尤其是刚接触编程的人,刚学习第一种语言的人.可是,当你一步步深入的时候,你会发现你没有了以前那种斗志.就好象你在玩韩国泡菜网游似的,玩到一定程度,每天就是练级练级,完全是一个想冲到高级别的意志力在支持着你.而学编程就更难了,学了两个月后,总是觉得你好象全都学会了,却又什么都做不了,又没有
架构师之spring-----spring3.0新特性的bean加载控制@DependsOn和@Lazy nannan408 Spring3
1.前言。如题。 2.描述。 @DependsOn用于强制初始化其他Bean。可以修饰Bean类或方法，使用该Annotation时可以指定一个字符串数组作为参数，每个数组元素对应于一个强制初始化的Bean。 @DependsOn({"steelAxe","abc"}) @Comp
Spring4+quartz2的配置和代码方式调度 Everyday都不同代码配置 spring4 quartz2.x 定时任务
前言：这些天简直被quartz虐哭。。因为quartz 2.x版本相比quartz1.x版本的API改动太多，所以，只好自己去查阅底层API…… quartz定时任务必须搞清楚几个概念： JobDetail——处理类 Trigger——触发器，指定触发时间，必须要有JobDetail属性，即触发对象 Scheduler——调度器，组织处理类和触发器，配置方式一般只需指定触发
Hibernate入门 tntxia Hibernate
前言使用面向对象的语言和关系型的数据库，开发起来很繁琐，费时。由于现在流行的数据库都不面向对象。Hibernate 是一个Java的ORM（Object/Relational Mapping）解决方案。 Hibernte不仅关心把Java对象对应到数据库的表中，而且提供了请求和检索的方法。简化了手工进行JDBC操作的流程。如
Math类 xiaoxing598 Math
一、Java中的数字（Math）类是final类，不可继承。 1、常数 PI：double圆周率 E：double自然对数 2、截取（注意方法的返回类型） double ceil(double d) 返回不小于d的最小整数 double floor(double d) 返回不大于d的整最大数 int round(float f) 返回四舍五入后的整数 long round