From cde48546bdbc6d0cb11134be3c0e9851af120376 Mon Sep 17 00:00:00 2001 From: ninglang Date: Sat, 11 May 2024 16:50:08 +0800 Subject: [PATCH] Site updated: 2024-05-11 16:50:07 --- search.xml | 1366 ++++++++++++++++++++++++++-------------------------- 1 file changed, 683 insertions(+), 683 deletions(-) diff --git a/search.xml b/search.xml index 22b76bd93..01486751c 100644 --- a/search.xml +++ b/search.xml @@ -1,139 +1,5 @@ - - C && C++ (1) - /2021/09/03/C_C++/ - describe some differences between c and c++,(Function Union and -Quote)

- -

Function

-
    -

  • Function declaration

    -

    if Function declaration's parameter is empty of -void,This two declaration in c++ are same :

    -
    f();				//This function don't carray any parameters
    f(void);			//This function don't carray any parameters
    -

    but they are different in c:

    -
    f(void);			//This function don't carray any parameters
    f();				//Don't give the information of parameters ,It have chance to carrary 						//paramters
    • -

  • Macro definition

    -

    Macro definition may cause some error that we can't expect ,for -example:

    -
    #include <iostream>
    using namespace std;
    #define doub(x) x*2
    int main()
    {
    	for(int i =1 ;i<4;i++)
    		cout<<i<<" doubled is "<<doub(i)<<endl;
    	cout<<"1+2 doubled is "<<doub(1+2)<<endl;
    	return 0;
    }
    -

    in line 8 ,we are expecting the result is :

    -
    1+2 doubled is 6
    -

    but in fact ,the result is :

    -
    1+2 double is 5
    -

    because the macro definition is replace the expression in the place -where it is called :

    -
    cout<<"1+2 doubled is "<<doub(1+2)<<endl;
    cout<<"1+2 doubled is "<<1+2*2<<endl;
    • -

  • Inline function

    -

    to avoid the unsafe of Marco definition ,We can use inline function -to replace the macro function to achieve more safe :

    -
    #include <iostream>
    using namespace std;
    inline int doub(int x);
    int main()
    {
    	for(int i =1 ;i<4;i++)
    		cout<<i<<" doubled is "<<doub(i)<<endl;
    	cout<<"1+2 doubled is "<<doub(1+2)<<endl;
    	return 0;
    }
    inline int doub(int x){
        return x*2;
    }
    • -

  • function with default value of parameters

    -

    the parameters with default value must be in the right of parameters -with no initial value:

    -
    int fun(int i ,int j=5,int k);     //incorrect 
    int fun(int i,int j,int k=5);      //correct
    • -

  • Function Overloading

    -

    The same function name can be used to define different tasks

    -
    #include <iostream>
    using namespace std;
    int square(int i)
    {
        return i*i;
    }
    long square(long i)
    {
        return i*i;
    }
    double square(double i)
    {
        return i*i;
    }
    int main()
    {
        int i =12;
        long j =1234;
        double k =1.23;
        cout<<"int i'quare is "<<square(i)<<endl;
        cout<<"long j's quare is "<<square(j)<<endl;
        cout<<"double k's quare is "<<square(k)<<endl;
        return 0;
    }
    -

    if only the type of return is not the same ,the numbers of parameter -and the type of parameters is same,The function couldn't be -overloaded:

    -
    int nihao(int x,int y);
    void nihao(int x,int y);     //That is incorrect ,because only the type of return is not the same
    -

    if the overloading function with default value parameter, it can be -incorrect :

    -
    void nihao(int a,int b=0);
    void nihao(int a);				//This is also incorrect the compiler can't decide which function should be choosed
    • -
-

Scope operator ::

-
    -

  • Priority

    -

    Local variables have higher priority than global variables

    -
    #include<iostream>
    using namespace std;
    int avar =10;			//global variable
    int main()
    {
    	int avar=3;			//local variable
    	cout<<"avar is "<<avar<<endl;
    	return 0;
    }
    -

    if global variables wants to be called in function ,we can add -:: in the front of variables

    -
    cout<<"local variable"<<avar<<endl;
    cout<<"global variable"<<::avar<<endl;
    • -
-

Union

-
    -

  • What is the Union

    -

    Union is a custom type ,we can create union in two way in c:

    -
    union data{
        int n;
        char ch;
        double f;
    };
    union data a,b,c;

    //second way
    union data{
        int n;
        char ch;
        double f;
    }a,b,c;
    -

    union's space is the largest memory footprint of all member -,int,char,double,the double's -memory footprint is largest ,so the union data's memory footprint is 8 -bits(the size of double)

    -
    #include<stdio.h>

    union data{
    	int n;
    	char ch;
    	short m;
    };

    int main()
    {
    	union data a;
    	printf("%d,%d\n",sizeof(a),sizeof(union data));
    	a.n = 0x40;
    	printf("%X,%c,%hX\n",a.n,a.ch,a.m);
    	a.ch ='9';
    	printf("%X,%c,%hX\n",a.n,a.ch,a.m);
    	a.m = 0x2059;
    	printf("%X,%c,%hX\n",a.n,a.ch,a.m);
    	a.n =0x3e25ad54;
    	printf("%X,%c,%hX\n",a.n,a.ch,a.m);
    	
    	return 0;
    }
    -

    you may get the result as follows:

    -
    4,4
    40,@,40
    39,9,39
    2059,Y,2059
    3E25AD54,T,AD54
    -

    so the result prove that union members will have Influence each -other, if you change one member's value ,the other member's value is -changed

    • -

  • How to store data

    -

    Union 's data is shared for all member ,so one of they is changed -,others will be effected,but the process is how to go

    -

    • -

  • Using union

    -

    student information and teacher information is recorded by the same -struct ,but some place are different,for example:

    - - - - - - - - - - - - - - - - - - - - - - - - - - -
    nameNumSexProfessionScore/course
    A1fs89
    B2mtmath
    -
    #include<stdio.h>
    #include<stdlib.h>

    #define NUM 4
    struct{
    	char name[40];
    	int num;
    	char sex;
    	char pro;
    	union d{
    		int score;
    		char course[10];
    	}sc;
    } bodys[NUM];
    int main(){
    	int i;
    	for(i=0;i<NUM;i++)
    	{
    		printf("Please input info:");
    		scanf("%s %d %c %c",&bodys[i].name,&bodys[i].num,&bodys[i].sex,&bodys[i].pro);
    		if (bodys[i].pro == 's'){
    			scanf("%d",&bodys[i].sc.score);
    			printf("\n%s\t%d\t%c\t%c\t%d",
                       bodys[i].name,bodys[i].num,bodys[i].sex,bodys[i].pro,bodys[i].sc.score);
    		}
    		else{
    			scanf("%s",&bodys[i].sc.course);
    			printf("\n%s\t%d\t%c\t%c\t%s",
                       bodys[i].name,bodys[i].num,bodys[i].sex,bodys[i].pro,bodys[i].sc.course);
    		}
    	}
    	return 0;
    }
    • -
-

Quote

-
    -

  • definition

    -

    give variables a another name after quoted ,the two variables are -equivalent when one of them changed ,the other will change

    -
    int i =5;
    int &j = i;		//delcare j is a integer quote ,and initialize j with i
    -

    but j definited in following way is not allowed:

    -
    int i;
    int &j;			//incorrect j is not linked some variables
    j = i;
    • -

  • quote and pointer

    -

    quote is another name for a variable ,but pointer is a tool pointing -to variable

    -
    #include<iostream>
    using namespace std;
    int main()
    {
    	int i=15;
    	int *iptr=&i;			//define a pointer 
    	int &rptr = i;			//define a quote 
    	cout<<"I is "<<i<<endl;
    	cout<<"*iptr is  "<<*iptr<<endl;
    	cout<<"rptr is "<<rptr<<endl;
    	i=29;
    	cout<<"After changing i to 29:"<<endl;
    	cout<<"i is "<<i<<endl;
    	cout<<"*iptr is  "<<*iptr<<endl;
    	cout<<"rptr is "<<rptr<<endl;
    	return 0;
    }
    -

    quote: No need & ,pointer : Need * -.

    • -

  • warn

    -
    int i,k;
    int &j =i;
    j =&k;   		//incorrect , delcare j is the quotation of k is not allowed
    -
    void &r = 10; 	//incorrect, void type is not allow 
    int &r = 10 ; 	//incorrect,can't assign quote "r" with value

    //can't quote array
    int a[4] = "amd";
    int &a[4] = a;


    //can't define quotation to quotation
    int n=3;
    int && r =n;
    int &*p = n;
    • -

  • used as parameters of function

    -
    #include<iostream>
    using namespace std;
    void swap(int &a,int &b)
    {
    	int temp =a;
    	a =b;
    	b =temp;
    }
    int main(){
    	int a=5,b=10;
    	cout<<"a="<<a<<" "<<"b="<<b;
    	swap(a,b);
    	cout<<"a="<<a<<" "<<"b="<<b;
    	return 0;
    }
    -

    quotation is used as formal parameter for function variable -transfer,but it seem that we have really passed a,b into the function -"swap"

    -
    #include<iostream>
    using namespace std;
    int a[] = {1,3,5,6,7,3};
    int &index(int);
    int main(){
    	index(1)=100;		//in fact ,because the return of funciton is not a number ,but a[i]
    	cout<<"a[1]="<<a[1]<<endl;
    	return 0;
    	
    }
    int &index(int i){
    	return a[i];
    }
    • -
-]]> - - coding - - Android Adb Command /2021/10/24/Android-Adb-Command/ @@ -306,284 +172,217 @@ href="">ipforbidden模块，刷入，即可 - 通信原理笔记 - /2023/05/23/Communication%20principle/ - 通信原理理解性笔记

- -

信道

-
-

将发送端数字脉冲信号转换成模拟信号的过程称为调制(Modulation)；将接收端模拟信号还原成数字脉冲信号的过程称为解调(Demodulation)。将调制和解调两种功能结合在一起的设备称为调制解调器(Modem)

-

模拟信号和数字信号之间可以相互转换：模拟信号一般通过PCM脉码调制(Pulse -Code -Modulation)方法量化为数字信号，即让模拟信号的不同幅度分别对应不同的二进制值，例如采用8位编码可将模拟信号量化为2^8=256个量级，实用中常采取24位或30位编码；数字信号一般通过对载波进行移相(Phase -Shift)的方法转换为模拟信号。

-

数字信道占用信道频带较宽。一路模拟电话的频带为4kHz带宽，一路数字电话约占64kHz，这是模拟通信目前仍有生命力的主要原因。

-
-

数字信道与模拟信道_模拟信道和数字信道_偷轮子的博客-CSDN博客

-

波形成型

-
-

从上图可以看出，相关时延大于符号持续时间，因此，当两个信号在接收侧相加时，来自于时延为的符号将会和来自于时延为的符号相加。

-

不同的符号相加，或者说，不同的符号相互干扰，即为符号间干扰(ISI)。

-

一般将多径信号最大时延的倒数定义为多径信道的相关带宽。

-
-

频率选择性失真和ISI是一体两面，其中，频率选择性失真发生在频域，对应的时域结果为ISI

-
-
-

衰落（2）-- -时延扩展，相关带宽，ISI - 知乎

-
-

脉冲整形

-

一、矩形脉冲

-

实际上矩形脉冲无失真传输是不可能的，因为由傅里叶变换可知，时域矩形脉冲，频域是sinc函数，带宽无限，而信道带宽总是有限的。 -失真严重导致采样判决出错，无法正确恢复数字信号。 -显然矩形脉冲信号不合适，sinc脉冲信号合适

-

二、sinc脉冲 其频谱有限，一个码元达到最大幅值时其他所有码元幅值刚好为零，码元之间不会相互影响，实现了无码间串扰。

-

基带滤波器

-

一般使用基带滤波器来实现脉冲整形

-

假设发送序列{1 1 1 -1 1 -1 -1 1} -发送序列、输入滤波器的冲激信号、每个冲激信号的冲激响应，和输出信号如图所示 -例子

-
-

基带信号的发送和接收的有效理解和掌握_滚降因子为0的系统可以算是理想低通系统吗_BIT小小书童的博客-CSDN博客

-
-

最初，信号是以矩形脉冲通过带限信道，必然会出现脉冲时延扩展引起S1，频域上看是Sa函数的旁瓣千扰。

-
-

简单概述：脉冲成形 -基带成形 （脉冲成型 基带成型） - HQU小西西 - 博客园

-

有点难，待会看

-

为什么要对基带信号进行脉冲成型【转载】 -- Riden - 博客园

-
-

为什么对基带信号要成形滤波？

-

基带信号带宽无限，需要限制带宽。成形滤波器也叫限带滤波器

-

实际中通信传输的信号大都是带通信号，也就是中心频带远大于频带宽度的信号。而这些带通信号的频谱结构只取决于等效低通信号的频谱结构。这里的等效低通信号就是你这里所指的基带数字信号。而基带数字信号的频率特性又取决于两个因素，一个是基带信号中构成每个脉冲符号的基本信号的频谱，另一个就是脉冲信号之间的相关性。换句话说可以通过设计不同的基本脉冲信号的波形和符号之间的相关性，达到改变基带信号频谱结构的目的，从而改变调制后带通信号的频谱特性。 -理解了这一点，你就可以理解为什么要对基带信号进行不同的滤波生成符号脉冲了。

-
-

基带传输与成形滤波_基带成型滤波器_长弓的坚持的博客-CSDN博客

-
-

为什么要->这里有直接结论：

-

（个人简单理解，脉冲成型（形），就是将脉冲变成其他的传输波形，理由就是压缩频谱来降低ISI） -！

-
-

简单概述：脉冲成形 -基带成形 （脉冲成型 基带成型） - 1024搜-程序员专属的搜索引擎

-
-

数字信号想要在信道中传输，必须在发射机的基带部分进行脉冲成形，将数字信号转换成脉冲信号，脉冲信号到达接收机后，在基带部分进行采样判决，将数字信号恢复出来。

-

如下图所示，脉冲成形需要用到脉冲波形，实现脉冲成形要用到基带滤波器，评估基带滤波器要用到眼图。【深入浅出通信原理-学习笔记】基带信号的发送和接收_脉冲怎么发送和接受_DUANDAUNNN的博客-CSDN博客

-
-]]> - - 电路 - - - - 动态规划入门 - /2021/08/19/DP/ - ​ 之前没搞懂的动态规划，现在强行试了一下，欢迎大家指导！

+ C && C++ (1) + /2021/09/03/C_C++/ + describe some differences between c and c++,(Function Union and +Quote)

-

Fibonacci Sequence

-
    -
  • 递归的思想 -
      -
    • 要求第n项，先求n-1和n-2项，若n-1和n-2项为1,2则都令为1
      • -
    • Fobonacci -Sequence复杂度比较高，不适合大数据计算，例如当n=100时，计算起来就十分的慢
      • -
    • -
-
def  fibo(n):
    if n==1 or n==2:
        return 1
    else:
        return fibo(n-1)+fibo(n-2)
-

​ -既然Fibonacci数列的递归计算如此复杂，那么，我们应该想什么办法来优化整个算法呢，我们考虑到，Fibonacci之所以复杂，是因为递归的存在，导致整个程序的时间复杂度都十分的高那么我们有没有简单一点的方法呢,对了，我们可以采用记录的方式，将每一个点之前的Fibonacci的数值都保存下来

-
def Fibo(n):
    memo=[1]*n     #新建一个备忘录，记录每一个点的斐波拉切数列值，初始为[1,1,1,1....]
    for i in range(n):
        if i<=1:
            memo[i]=1   #给备忘录的第一个元素和第二个元素附一个1的初值
        else:
            memo[i]=memo[i-1]+memo[i-2] #生成整个memo数组
    return memo[i]   #返回memo最后一个值，就是整个要求的的最大值
#调用一下
Fibo(100)
-

​ -我们调用了相关的带有memo的Fibo函数之后，明显发现，整个速度提升了很多，整个计算没有超过一秒钟，显然，这种方法是很有效的，我们称这个memo为DP数组

-

House-robber

+

Function

    -
  • 你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。给定一个代表每个房屋存放金额的非负整数数组，计算你 -不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
    • -
  • 输入：[1,2,3,1]
    • -
-

输出：4

-

解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。

-

偷窃到的最高金额 = 1 + 3 = 4 。

-

对于小偷问题，我们可以这么去思考，就是我们新建一个DP数组，用来储存小偷走到这个点时之前可以得到的最大的收益，如果按照这种思路，然后去整个数组的最大值

-
def steal():
    nums=[1,2,3,1]   #每个房子有的金额（金额数组）
    memo=[1]*len(nums)    #新建一个DP数组，这个数组就是记录到那个点的最大值
    for i in  range(len(memo)):     #完善数组，for循环，开始从第一个位置开始填充数组
        if i==0:
            memo[i]=nums[i]         #前两家偷的时候，只能偷其中一家，所以最大值为两家中的一家
        elif i==1:
            memo[i]=max(nums[i],nums[i-1])     #第二家的最大金额，应该是偷第一家和偷第二家的最大之一
        else:
            memo[i]=max(memo[i-2]+nums[i],memo[i-1])    #用户大于第三家之后，数组的值应该为偷这一家(不能连续偷)(memo[i-2]+nums[i])
            #如果偷了的金额没有不偷多，那就不偷
    print(max(memo))
    print(memo)  
steal()
-

Maximum value of gifts

-

在一个 m*n -的棋盘的每一格都放有一个礼物，每个礼物都有一定的价值（价值大于 -0）。你可以从棋盘的左上角开始拿格子里的礼物，并每次向右或者向下移动一格、直到到达棋盘的右下角。给定一个棋盘及其上面的礼物的价值，请计算你最多能拿到多少价值的礼物？

-

输入:

-

[

-

[1,3,1],

-

[1,5,1],

-

[4,2,1]

-

]

-

输出: 12

-

解释: 路径 1→3→5→2→1 可以拿到最多价值的礼物

-

image-20210819174221935

-

​ -我们要计算从左上角到右下角最大的礼物价值，我们不妨这么思考，我们还是新建一个DP数组，这个DP数组应该是二维的，然后考虑DP数组是左上角到达每个点的最大价值，又因为路线只能右走或者下走。所以当其为横向、纵向的边界时，我们只要考虑左边、上面

-
def gift():
    a=[
      [1,3,1],
      [1,5,1],
      [4,2,1]
    ]
    r,c=len(a),len(a[0])   #读取出数组的长度r代表row，c代表column
    memo=[]
    for i in range(r):
        memo.append([1]*c)   #初始化DP数组，让DP数组的大小为原来a的大小
    for i in range(r):       #遍历整个二维的a，然后开始填充memo的每一个地方
        for j in range(c):
            if i==0 and j==0:
                memo[i][j]=a[i][j]    #第一个位置为起点，所以必须为a的第一个值
            elif i==0:
                memo[i][j]=memo[i][j-1]+a[i][j]    #当i=0时，说明第一行数据，由于只能右走和下走，所以
                                                    #这里是右走
            elif j==0:
                memo[i][j]=memo[i-1][j]+a[i][j]    #当i=0时，说明第一列数据，由于只能右走和下走，所以
                                                    #这里是下走
            else:
                memo[i][j]=max(memo[i][j-1]+a[i][j],memo[i-1][j]+a[i][j])
                                                #当i!=0,j!=0时，可以右走和下走
                
    print(memo)
-

Coins exchange

-

给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount -，表示总金额。计算并返回可以凑成总金额所需的 最少的硬币个数 -。如果没有任何一种硬币组合能组成总金额，返回 -1 -。你可以认为每种硬币的数量是无限的。

-

输入：coins = [1, 2, 5], S = 11

-

输出：3

-

解释：11 = 5 + 5 + 1

-

输入：coins = [2], S = 3

-

输出：-1

-

image-20210819174503970

-

\[ -f(x)=min\{f(x-c_1),f(x-c_2),...f(x-c_m)\}+1 -\]

-

如果\(x-c_i<0\)，则令\(f(x-c_i)=\infty\)这样就不会选这个\(f(x-c_i)\)了

-

如果\(x-c_i=0\),那么\(f(x-c_i)=0\)即\(f(0)=0\)

-
def change_coins():
    coins,S=[1,2,5],11    #拥有的硬币的种类，个数
    dp={}                 #定义一个dp的字典，记录到每一元钱，所需要的硬币个数
    temp=[]
    for i  in range(S+1):   #一直需要到11，所以这里是0-12
        for j in coins:
            if i-j==0:     #先判断这个x-c_i是不是等于0，如果是，令min{....}的数组中添加0
                temp.append(0)
            elif i-j<0:    #在判断i-j是不是小于0，如果是，这说明这条路不行，于是令min{...}的...中添加一个数1000
                temp.append(1000) 
            else:          #在其他的情况下都是满足的，那么可以按照上面的公式，在这个可能的结果中添加一个数为dp.get(i-j)
                temp.append(dp.get(i-j))
        dp[i]=min(temp)+1  #dp[i]则应该为上面的一个数组中的一个数的最小值加一即min{[....]}+1
        temp=[]            #记得给数组归0
#     print(dp)
    return dp
change_coins()
-

现在我们已经知道硬币的最少组合为3，那我们如何得到是哪些硬币的组合

-

思路： -我们可以将S=11的最小硬币数是3分解一下，例如，硬币数是3，说明[1,2,5]中的三个可以组成，于是我们可以一个一个的遍历，看当11减去其中的一些数之后判断一下剩余的需要的最小硬币数是不是2，例如:11-1,然后:凑成10元的所需硬币数最小是2吗，是的话，跳出遍历，选择这一10继续分解，不是的话，继续遍历下面的，直到S=0说明已经遍历到0了，可以结束

-

如何得到硬币的组合呢（5，5，1）

-
def find_coins(S):
    dp=change_coins()    #调用上面的硬币交换得到dp数组
    coins=[1,2,5]       #硬币的种类为1,2,5
    n=dp.get(S)         #第一步先调出S的最小硬币数
    dp[0]=0             #给dp数组的0元素归0
    go,coin_cate=[],[]   #go数组可以记录整个换钱的过程，coin_cate可以看出每个过程所使用的硬币的金额
    while dp.get(S,0)-1>=0:     #当dp.get(S,0)-1=0时，说明S为非零且属于[1,2,5]
        for i in coins:         #从[1,2,5]中一个个取数
            if n-1==dp.get(S-i):    #如果有需要凑成S-i的钱的最小个数与S需要的最小个数只相差1，那么符合
                                    #取其中一种情况即可
                go.append(S-i)      #把这个可以凑成的金额添加到路径里
                coin_cate.append(i)  #把这次使用的种类添加到硬币的种类里
                S=S-i                #给S从新赋值，让S=S-i，以便寻找下一轮循环
                break                #只要找到满足条件的一个coins即可，不需要全部找到
        n=dp.get(S,0)
        if S==0:                     #如果S=0，说明整个分解可凑的钱程序已经已经走到需要凑0元的情况，
                                    #显然这种情况可以直接结束程序
            break
    print(go,coin_cate)
find_coins(11)
-

Knapsack Problem

-

​ -有10件货物要从甲地运送到乙地，每件货物的重量(单位:吨)和利润(单位:元)

-

如下表所示:

-

image-20210819174323036

-

​ -由于只有--辆最大载重为30t的货车能用来运送货物，所以只能选择部分货物配送，要求确定运送哪些货物，使得运送这些货物的总利润最大。

-

思路：

-

​ 有m件物品，第i件物品的利润为\(v_i\)重量为\(w_i\)背包的总重量为W.

-

原问题:在满足重量约束的条件下，将这m个物品选择性放入容量为W的背包所能获得的最大利润

-

子问题:在满足重量的约束条件下，将i(\(i\le -m\))件物品选择性放入容量为j(\(j \le -W\))的背包所获得的最大利润

-

状态分析:

-

​ -我们要讲m件商品装进容量为W的背包，我们可以假设背包是从1,2,3,4...增大的容量，物品从第一次只装第一个产品，然后慢慢推广到前i个产品，所以DP表格其实是在背包容量为i的情况下，能装的礼物的最大价值

-

​ -对于第一行来说，装的物品为第一个物品，所以只需要判断背包容量是否大于第一件物品的重量，若大于，则最大价值为第一件物品的价值

-

​ -对于第一列来说，背包容量为1，装进前i件物品的最大价值，由于物品的重量始终为整数，所以在前i件物品里，我们要看有没有总量为1的物品，若没有，则什么也装不进去，那么最大价值为0，若有(可能有几个)，则去前i个产品中重量为1的所有物品中价值最大的那个为该点dp表的值

-

​ 对于其它的列来说，需要用到状态转移方程，对于要求前\(i\)件物品装进容量为\(j\)的背包，在\(i-1\)的基础上只需要考虑到底装不装第\(i\)件物品，那么怎么考虑呢？要装第\(i\)件物品首先，第\(i\)件物品的重量必须小于背包的容量所以有: ​ -\(j-weight(i)>=0\)才去判断: \[ -max(dp[i-1][j],dp[i-1][j-weight[i]]+value[i]) -\]

-

它的意思是如果第i件物品装的下，那么就去判断不装这件物品和在没装这件物品，也就是dp[i-1][j-weight[i]]的最大价值，然后加上这件物品的价值。这样就可推出整个dp数组，而数组的最后一个元素，就是我们要求的最大价值

-
items=[(1,6,540),(2,3,200),(3,4,180),(4,5,350),(5,1,60),(6,2,150),(7,3,280),(8,5,450),(9,4,320),(10,2,120)]
# 定义一个含有所有的价值的数组
weight=30   # 定义背包的重量
def bag_problem():
    dp=[]     #定义dp数组
    for i in range(len(items)):    #初始化dp数组
        dp.append([0]*weight)
    for i in range(len(items)):      #双重遍历开始填充数组
        for j in range(weight):
            if i==0 :
                if j>=items[0][1]-1:    #背包大小大于等于物体的大小，物体大小为定值，则为items的价值
                    dp[i][j]=items[0][2]
                else :
                    dp[i][j]=0          #如果背包太小，那就价值为0
            if j==0 :                   #探究第一列的值
                if items[i][1]==1:
                    dp[i][j]=max(dp[i-1][0],items[i][2])      #如果可以装进去，前i个产品中重量为1的所有物品中价值最大
                else:
                    dp[i][j]=dp[i-1][j]             #重量超过一的物品无法装入，直接用重量为1的物体价值最大的那个作为dp[i][j]
            else:                      #探究其它列
#                 print(j)
                if j+1-items[i][1]<0:   #如果背包转不下就只能是dp[i-1][j],相当于不装第i件
                    dp[i][j]=dp[i-1][j]
                else:                   #其它情况判断背包产生的价值是否大于没装时候产生的价值
                    dp[i][j]=max(dp[i-1][j],dp[i-1][j-items[i][1]]+items[i][2])
    return dp
#     for c in dp:
#         print(c)
for i in bag_problem():
    print(i)
+

  • Function declaration

    +

    if Function declaration's parameter is empty of +void,This two declaration in c++ are same :

    +
    f();				//This function don't carray any parameters
    f(void);			//This function don't carray any parameters
    +

    but they are different in c:

    +
    f(void);			//This function don't carray any parameters
    f();				//Don't give the information of parameters ,It have chance to carrary 						//paramters
    • +

  • Macro definition

    +

    Macro definition may cause some error that we can't expect ,for +example:

    +
    #include <iostream>
    using namespace std;
    #define doub(x) x*2
    int main()
    {
    	for(int i =1 ;i<4;i++)
    		cout<<i<<" doubled is "<<doub(i)<<endl;
    	cout<<"1+2 doubled is "<<doub(1+2)<<endl;
    	return 0;
    }
    +

    in line 8 ,we are expecting the result is :

    +
    1+2 doubled is 6
    +

    but in fact ,the result is :

    +
    1+2 double is 5
    +

    because the macro definition is replace the expression in the place +where it is called :

    +
    cout<<"1+2 doubled is "<<doub(1+2)<<endl;
    cout<<"1+2 doubled is "<<1+2*2<<endl;
    • +

  • Inline function

    +

    to avoid the unsafe of Marco definition ,We can use inline function +to replace the macro function to achieve more safe :

    +
    #include <iostream>
    using namespace std;
    inline int doub(int x);
    int main()
    {
    	for(int i =1 ;i<4;i++)
    		cout<<i<<" doubled is "<<doub(i)<<endl;
    	cout<<"1+2 doubled is "<<doub(1+2)<<endl;
    	return 0;
    }
    inline int doub(int x){
        return x*2;
    }
    • +

  • function with default value of parameters

    +

    the parameters with default value must be in the right of parameters +with no initial value:

    +
    int fun(int i ,int j=5,int k);     //incorrect 
    int fun(int i,int j,int k=5);      //correct
    • +

  • Function Overloading

    +

    The same function name can be used to define different tasks

    +
    #include <iostream>
    using namespace std;
    int square(int i)
    {
        return i*i;
    }
    long square(long i)
    {
        return i*i;
    }
    double square(double i)
    {
        return i*i;
    }
    int main()
    {
        int i =12;
        long j =1234;
        double k =1.23;
        cout<<"int i'quare is "<<square(i)<<endl;
        cout<<"long j's quare is "<<square(j)<<endl;
        cout<<"double k's quare is "<<square(k)<<endl;
        return 0;
    }
    +

    if only the type of return is not the same ,the numbers of parameter +and the type of parameters is same,The function couldn't be +overloaded:

    +
    int nihao(int x,int y);
    void nihao(int x,int y);     //That is incorrect ,because only the type of return is not the same
    +

    if the overloading function with default value parameter, it can be +incorrect :

    +
    void nihao(int a,int b=0);
    void nihao(int a);				//This is also incorrect the compiler can't decide which function should be choosed
    • + +

    Scope operator ::

    +
      +

    • Priority

      +

      Local variables have higher priority than global variables

      +
      #include<iostream>
      using namespace std;
      int avar =10;			//global variable
      int main()
      {
      	int avar=3;			//local variable
      	cout<<"avar is "<<avar<<endl;
      	return 0;
      }
      +

      if global variables wants to be called in function ,we can add +:: in the front of variables

      +
      cout<<"local variable"<<avar<<endl;
      cout<<"global variable"<<::avar<<endl;
      • +
    +

    Union

    +
      +

    • What is the Union

      +

      Union is a custom type ,we can create union in two way in c:

      +
      union data{
          int n;
          char ch;
          double f;
      };
      union data a,b,c;

      //second way
      union data{
          int n;
          char ch;
          double f;
      }a,b,c;
      +

      union's space is the largest memory footprint of all member +,int,char,double,the double's +memory footprint is largest ,so the union data's memory footprint is 8 +bits(the size of double)

      +
      #include<stdio.h>

      union data{
      	int n;
      	char ch;
      	short m;
      };

      int main()
      {
      	union data a;
      	printf("%d,%d\n",sizeof(a),sizeof(union data));
      	a.n = 0x40;
      	printf("%X,%c,%hX\n",a.n,a.ch,a.m);
      	a.ch ='9';
      	printf("%X,%c,%hX\n",a.n,a.ch,a.m);
      	a.m = 0x2059;
      	printf("%X,%c,%hX\n",a.n,a.ch,a.m);
      	a.n =0x3e25ad54;
      	printf("%X,%c,%hX\n",a.n,a.ch,a.m);
      	
      	return 0;
      }
      +

      you may get the result as follows:

      +
      4,4
      40,@,40
      39,9,39
      2059,Y,2059
      3E25AD54,T,AD54
      +

      so the result prove that union members will have Influence each +other, if you change one member's value ,the other member's value is +changed

      • +

    • How to store data

      +

      Union 's data is shared for all member ,so one of they is changed +,others will be effected,but the process is how to go

      +

      • +

    • Using union

      +

      student information and teacher information is recorded by the same +struct ,but some place are different,for example:

      + + + + + + + + + + + + + + + + + + + + + + + + + + +
      nameNumSexProfessionScore/course
      A1fs89
      B2mtmath
      +
      #include<stdio.h>
      #include<stdlib.h>

      #define NUM 4
      struct{
      	char name[40];
      	int num;
      	char sex;
      	char pro;
      	union d{
      		int score;
      		char course[10];
      	}sc;
      } bodys[NUM];
      int main(){
      	int i;
      	for(i=0;i<NUM;i++)
      	{
      		printf("Please input info:");
      		scanf("%s %d %c %c",&bodys[i].name,&bodys[i].num,&bodys[i].sex,&bodys[i].pro);
      		if (bodys[i].pro == 's'){
      			scanf("%d",&bodys[i].sc.score);
      			printf("\n%s\t%d\t%c\t%c\t%d",
                         bodys[i].name,bodys[i].num,bodys[i].sex,bodys[i].pro,bodys[i].sc.score);
      		}
      		else{
      			scanf("%s",&bodys[i].sc.course);
      			printf("\n%s\t%d\t%c\t%c\t%s",
                         bodys[i].name,bodys[i].num,bodys[i].sex,bodys[i].pro,bodys[i].sc.course);
      		}
      	}
      	return 0;
      }
      • +
    +

    Quote

    +
      +

    • definition

      +

      give variables a another name after quoted ,the two variables are +equivalent when one of them changed ,the other will change

      +
      int i =5;
      int &j = i;		//delcare j is a integer quote ,and initialize j with i
      +

      but j definited in following way is not allowed:

      +
      int i;
      int &j;			//incorrect j is not linked some variables
      j = i;
      • +

    • quote and pointer

      +

      quote is another name for a variable ,but pointer is a tool pointing +to variable

      +
      #include<iostream>
      using namespace std;
      int main()
      {
      	int i=15;
      	int *iptr=&i;			//define a pointer 
      	int &rptr = i;			//define a quote 
      	cout<<"I is "<<i<<endl;
      	cout<<"*iptr is  "<<*iptr<<endl;
      	cout<<"rptr is "<<rptr<<endl;
      	i=29;
      	cout<<"After changing i to 29:"<<endl;
      	cout<<"i is "<<i<<endl;
      	cout<<"*iptr is  "<<*iptr<<endl;
      	cout<<"rptr is "<<rptr<<endl;
      	return 0;
      }
      +

      quote: No need & ,pointer : Need * +.

      • +

    • warn

      +
      int i,k;
      int &j =i;
      j =&k;   		//incorrect , delcare j is the quotation of k is not allowed
      +
      void &r = 10; 	//incorrect, void type is not allow 
      int &r = 10 ; 	//incorrect,can't assign quote "r" with value

      //can't quote array
      int a[4] = "amd";
      int &a[4] = a;


      //can't define quotation to quotation
      int n=3;
      int && r =n;
      int &*p = n;
      • +

    • used as parameters of function

      +
      #include<iostream>
      using namespace std;
      void swap(int &a,int &b)
      {
      	int temp =a;
      	a =b;
      	b =temp;
      }
      int main(){
      	int a=5,b=10;
      	cout<<"a="<<a<<" "<<"b="<<b;
      	swap(a,b);
      	cout<<"a="<<a<<" "<<"b="<<b;
      	return 0;
      }
      +

      quotation is used as formal parameter for function variable +transfer,but it seem that we have really passed a,b into the function +"swap"

      +
      #include<iostream>
      using namespace std;
      int a[] = {1,3,5,6,7,3};
      int &index(int);
      int main(){
      	index(1)=100;		//in fact ,because the return of funciton is not a number ,but a[i]
      	cout<<"a[1]="<<a[1]<<endl;
      	return 0;
      	
      }
      int &index(int i){
      	return a[i];
      }
      • +
    ]]>     coding     - 专业英语 - /2023/06/05/English_profess/ - GANs

    -

    专业英语答辩

    + 通信原理笔记 + /2023/05/23/Communication%20principle/ + 通信原理理解性笔记

    +

    信道

    -

    大家好，欢迎大家来到这里，今天我将为大家介绍一个用于图像翻译的新的技术，叫做cycle-gan,其是由AI华人青年学者Jun-Yan -Zhu主导的项目，在介绍这篇paper之前，我们先和大家介绍一些较为相近的领域。

    +

    将发送端数字脉冲信号转换成模拟信号的过程称为调制(Modulation)；将接收端模拟信号还原成数字脉冲信号的过程称为解调(Demodulation)。将调制和解调两种功能结合在一起的设备称为调制解调器(Modem)

    +

    模拟信号和数字信号之间可以相互转换：模拟信号一般通过PCM脉码调制(Pulse +Code +Modulation)方法量化为数字信号，即让模拟信号的不同幅度分别对应不同的二进制值，例如采用8位编码可将模拟信号量化为2^8=256个量级，实用中常采取24位或30位编码；数字信号一般通过对载波进行移相(Phase +Shift)的方法转换为模拟信号。

    +

    数字信道占用信道频带较宽。一路模拟电话的频带为4kHz带宽，一路数字电话约占64kHz，这是模拟通信目前仍有生命力的主要原因。

    -

    First

    -

    Hello everyone, welcome to come here, today I will introduce a new -technology for image translation, called cycle-gan, which is a project -led by young AI Chinese scholar Jun-Yan Zhu, in this paper Before that, -let's introduce some relatively similar fields to you.

    +

    数字信道与模拟信道_模拟信道和数字信道_偷轮子的博客-CSDN博客

    +

    波形成型

    -

    你们了解文心一言、或者是chatgpt，或许是由Google开发的bard吗？他们的共性是什么呢？没错，他们的共性就是都具有创造性，所谓的创造性，就是当你输入同一句话的时候，它能给出不同的结果，所以gpt的第一个单词就是Generative，但是CNN可不擅长生成式模型，当你给出同一个输入时，它更倾向于输出同一结果。

    +

    从上图可以看出，相关时延大于符号持续时间，因此，当两个信号在接收侧相加时，来自于时延为的符号将会和来自于时延为的符号相加。

    +

    不同的符号相加，或者说，不同的符号相互干扰，即为符号间干扰(ISI)。

    +

    一般将多径信号最大时延的倒数定义为多径信道的相关带宽。

    +
    +

    频率选择性失真和ISI是一体两面，其中，频率选择性失真发生在频域，对应的时域结果为ISI

    -

    Do you guys know Wenxinyiyan, or chatgpt, maybe bard developed by -Google? What do they have in common? Yes, what they have in common is -that they are all creative. The so-called creativity means that when you -input the same sentence, it can give different results, so the first -word of gpt is Generative, but CNN is not good at generative models. , -when you give the same input, it is more likely to output the same -result.

    +
    +

    衰落（2）-- +时延扩展，相关带宽，ISI - 知乎

    -

    另一个例子就是跨域识别问题，如何通过一个训练的模型，去泛化识别其它域的问题，这里就涉及到域适应，而gan就是用来解决这种问题的。

    +

    脉冲整形

    +

    一、矩形脉冲

    +

    实际上矩形脉冲无失真传输是不可能的，因为由傅里叶变换可知，时域矩形脉冲，频域是sinc函数，带宽无限，而信道带宽总是有限的。 +失真严重导致采样判决出错，无法正确恢复数字信号。 +显然矩形脉冲信号不合适，sinc脉冲信号合适

    +

    二、sinc脉冲 其频谱有限，一个码元达到最大幅值时其他所有码元幅值刚好为零，码元之间不会相互影响，实现了无码间串扰。

    +

    基带滤波器

    +

    一般使用基带滤波器来实现脉冲整形

    +

    假设发送序列{1 1 1 -1 1 -1 -1 1} +发送序列、输入滤波器的冲激信号、每个冲激信号的冲激响应，和输出信号如图所示 +例子

    -

    Another example is the problem of cross-domain recognition. How to -generalize and recognize other domains through a trained model, here -involves domain adaptation, and gan is used to solve this problem.

    +

    基带信号的发送和接收的有效理解和掌握_滚降因子为0的系统可以算是理想低通系统吗_BIT小小书童的博客-CSDN博客

    -

    这是Gan的一个模型框架，主要是由生成器和判别器两部分组成，生成器用来生成内容，而判别器主要识别生成的内容是否是假的。生成器和判别器是两个模型，他们就如自然界一样捕食者与被捕食者共同进化。当判别器无法区分生成的内容是否为假，说明模型已经表现十分良好了

    +

    最初，信号是以矩形脉冲通过带限信道，必然会出现脉冲时延扩展引起S1，频域上看是Sa函数的旁瓣千扰。

    -

    This is a model framework of Gan, which is mainly composed of two -parts: the generator and the discriminator. The generator is used to -generate content, and the discriminator mainly identifies whether the -generated content is fake. The generator and the discriminator are two -models, and they co-evolve with the prey just like in nature. When the -discriminator cannot distinguish whether the generated content is fake -or not, it means that the model has performed very well

    +

    简单概述：脉冲成形 +基带成形 （脉冲成型 基带成型） - HQU小西西 - 博客园

    +

    有点难，待会看

    +

    为什么要对基带信号进行脉冲成型【转载】 +- Riden - 博客园

    -

    Cycle-gan 使用了循环一致性，共需要四个模型，即两个生成模型GA->B, -GB->A,以及两个判别模型 -DA和DB，这就是cycle的由来，但是更加令人振奋人心的是：cycle-gan不需要配对的数据对进行训练，也就是说我们只需要给cycle-gan足够多的源域和目的域的数据，而不需要对其进行大量标签工作，它就会自动学习并且成功x -域到y域的转化规则，由于其涉及到两个域的双向转化，因而其迭代中使用的损失函数也是循环一致损失函数。

    +

    为什么对基带信号要成形滤波？

    +

    基带信号带宽无限，需要限制带宽。成形滤波器也叫限带滤波器

    +

    实际中通信传输的信号大都是带通信号，也就是中心频带远大于频带宽度的信号。而这些带通信号的频谱结构只取决于等效低通信号的频谱结构。这里的等效低通信号就是你这里所指的基带数字信号。而基带数字信号的频率特性又取决于两个因素，一个是基带信号中构成每个脉冲符号的基本信号的频谱，另一个就是脉冲信号之间的相关性。换句话说可以通过设计不同的基本脉冲信号的波形和符号之间的相关性，达到改变基带信号频谱结构的目的，从而改变调制后带通信号的频谱特性。 +理解了这一点，你就可以理解为什么要对基带信号进行不同的滤波生成符号脉冲了。

    -

    Cycle-gan uses cycle consistency and requires a total of four models, -namely two generative models GA->B, GB->A, and two discriminative -models DA and DB. This is the origin of cycle, but it is even more -exciting What is popular is that cycle-gan does not require paired data -pairs for training, that is to say, we only need to give cycle-gan -enough data from the source domain and the target domain without a lot -of labeling work on it, and it will Automatically learn and successfully -convert the x domain to the y domain. Since it involves the two-way -conversion of the two domains, the loss function used in its iteration -is also a cycle consistent loss function.

    -

    second

    +

    基带传输与成形滤波_基带成型滤波器_长弓的坚持的博客-CSDN博客

    -

    接下来给大家介绍一些cycle-gan应用:如视频增强领域，黑白视频变成彩色视频。或者是场景转化。或者是将抽象的画转化为一个具象的画如房屋建筑，这些都可以作为通信数据压缩，你可以试着一下发送方在网路上传送类似于色块一样的数据，它可能占用的带宽十分的小，当你在接收端受到这些色块时，再将其恢复出来。这样看起来是一个不错的视频压缩方法

    +

    为什么要->这里有直接结论：

    +

    （个人简单理解，脉冲成型（形），就是将脉冲变成其他的传输波形，理由就是压缩频谱来降低ISI） +！

    +
    +

    简单概述：脉冲成形 +基带成形 （脉冲成型 基带成型） - 1024搜-程序员专属的搜索引擎

    +
    +

    数字信号想要在信道中传输，必须在发射机的基带部分进行脉冲成形，将数字信号转换成脉冲信号，脉冲信号到达接收机后，在基带部分进行采样判决，将数字信号恢复出来。

    +

    如下图所示，脉冲成形需要用到脉冲波形，实现脉冲成形要用到基带滤波器，评估基带滤波器要用到眼图。【深入浅出通信原理-学习笔记】基带信号的发送和接收_脉冲怎么发送和接受_DUANDAUNNN的博客-CSDN博客

    -

    Next, I will introduce some cycle-gan applications: for example, in -the field of video enhancement, black-and-white video becomes color -video. Or scene transformation. Or convert an abstract painting into a -concrete painting such as a building, these can be used as communication -data compression, you can try the sender to transmit data similar to -color blocks on the network, it may take up a lot of bandwidth Small, -when you get these color patches at the receiving end, bring them back. -This looks like a good way to compress video

    -

    Third

    -

    The third part is sentence analysis，

    -

    The meaning of the first sentence is -“此外，在实践中，我们发现很难优化对抗目标隔离：标准程序通常会导致众所周知的模式崩溃问题，其中所有输入图像都映射到相同的输出图像，优化无法取得进展 -[15]。

    -

    ”。

    -

    The second sentence -means：“我们还与以前依赖于手动定义的样式和内容分解或共享嵌入函数的方法进行了比较，并表明我们的方法优于这些基线。”。

    -

    The third part is sentence analysis -“图像到图像转换的想法至少可以追溯到 Hertzmann 等人的图像类比 -[19]，他们在单个输入输出训练图像对上采用非参数纹理模型 [10]。”

    -

    Here are some references. thanks for listening！

    ]]>     - code + 电路     @@ -634,11 +433,126 @@ alt="TTL三态门" />
      -
    • OC门和OD的优势：电平偏移，也就是说，输出的电平可以通过上拉电阻来调整
      • +
    • OC门和OD的优势：电平偏移，也就是说，输出的电平可以通过上拉电阻来调整
      • +
    +]]> + + 电子 + +     + + 动态规划入门 + /2021/08/19/DP/ + ​ 之前没搞懂的动态规划，现在强行试了一下，欢迎大家指导！

    + +

    Fibonacci Sequence

    +
      +
    • 递归的思想 +
        +
      • 要求第n项，先求n-1和n-2项，若n-1和n-2项为1,2则都令为1
        • +
      • Fobonacci +Sequence复杂度比较高，不适合大数据计算，例如当n=100时，计算起来就十分的慢
        • +
      • +
    +
    def  fibo(n):
        if n==1 or n==2:
            return 1
        else:
            return fibo(n-1)+fibo(n-2)
    +

    ​ +既然Fibonacci数列的递归计算如此复杂，那么，我们应该想什么办法来优化整个算法呢，我们考虑到，Fibonacci之所以复杂，是因为递归的存在，导致整个程序的时间复杂度都十分的高那么我们有没有简单一点的方法呢,对了，我们可以采用记录的方式，将每一个点之前的Fibonacci的数值都保存下来

    +
    def Fibo(n):
        memo=[1]*n     #新建一个备忘录，记录每一个点的斐波拉切数列值，初始为[1,1,1,1....]
        for i in range(n):
            if i<=1:
                memo[i]=1   #给备忘录的第一个元素和第二个元素附一个1的初值
            else:
                memo[i]=memo[i-1]+memo[i-2] #生成整个memo数组
        return memo[i]   #返回memo最后一个值，就是整个要求的的最大值
    #调用一下
    Fibo(100)
    +

    ​ +我们调用了相关的带有memo的Fibo函数之后，明显发现，整个速度提升了很多，整个计算没有超过一秒钟，显然，这种方法是很有效的，我们称这个memo为DP数组

    +

    House-robber

    +
      +
    • 你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。给定一个代表每个房屋存放金额的非负整数数组，计算你 +不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。
      • +
    • 输入：[1,2,3,1]
    +

    输出：4

    +

    解释：偷窃 1 号房屋 (金额 = 1) ，然后偷窃 3 号房屋 (金额 = 3)。

    +

    偷窃到的最高金额 = 1 + 3 = 4 。

    +

    对于小偷问题，我们可以这么去思考，就是我们新建一个DP数组，用来储存小偷走到这个点时之前可以得到的最大的收益，如果按照这种思路，然后去整个数组的最大值

    +
    def steal():
        nums=[1,2,3,1]   #每个房子有的金额（金额数组）
        memo=[1]*len(nums)    #新建一个DP数组，这个数组就是记录到那个点的最大值
        for i in  range(len(memo)):     #完善数组，for循环，开始从第一个位置开始填充数组
            if i==0:
                memo[i]=nums[i]         #前两家偷的时候，只能偷其中一家，所以最大值为两家中的一家
            elif i==1:
                memo[i]=max(nums[i],nums[i-1])     #第二家的最大金额，应该是偷第一家和偷第二家的最大之一
            else:
                memo[i]=max(memo[i-2]+nums[i],memo[i-1])    #用户大于第三家之后，数组的值应该为偷这一家(不能连续偷)(memo[i-2]+nums[i])
                #如果偷了的金额没有不偷多，那就不偷
        print(max(memo))
        print(memo)  
    steal()
    +

    Maximum value of gifts

    +

    在一个 m*n +的棋盘的每一格都放有一个礼物，每个礼物都有一定的价值（价值大于 +0）。你可以从棋盘的左上角开始拿格子里的礼物，并每次向右或者向下移动一格、直到到达棋盘的右下角。给定一个棋盘及其上面的礼物的价值，请计算你最多能拿到多少价值的礼物？

    +

    输入:

    +

    [

    +

    [1,3,1],

    +

    [1,5,1],

    +

    [4,2,1]

    +

    ]

    +

    输出: 12

    +

    解释: 路径 1→3→5→2→1 可以拿到最多价值的礼物

    +

    image-20210819174221935

    +

    ​ +我们要计算从左上角到右下角最大的礼物价值，我们不妨这么思考，我们还是新建一个DP数组，这个DP数组应该是二维的，然后考虑DP数组是左上角到达每个点的最大价值，又因为路线只能右走或者下走。所以当其为横向、纵向的边界时，我们只要考虑左边、上面

    +
    def gift():
        a=[
          [1,3,1],
          [1,5,1],
          [4,2,1]
        ]
        r,c=len(a),len(a[0])   #读取出数组的长度r代表row，c代表column
        memo=[]
        for i in range(r):
            memo.append([1]*c)   #初始化DP数组，让DP数组的大小为原来a的大小
        for i in range(r):       #遍历整个二维的a，然后开始填充memo的每一个地方
            for j in range(c):
                if i==0 and j==0:
                    memo[i][j]=a[i][j]    #第一个位置为起点，所以必须为a的第一个值
                elif i==0:
                    memo[i][j]=memo[i][j-1]+a[i][j]    #当i=0时，说明第一行数据，由于只能右走和下走，所以
                                                        #这里是右走
                elif j==0:
                    memo[i][j]=memo[i-1][j]+a[i][j]    #当i=0时，说明第一列数据，由于只能右走和下走，所以
                                                        #这里是下走
                else:
                    memo[i][j]=max(memo[i][j-1]+a[i][j],memo[i-1][j]+a[i][j])
                                                    #当i!=0,j!=0时，可以右走和下走
                    
        print(memo)
    +

    Coins exchange

    +

    给你一个整数数组 coins ，表示不同面额的硬币；以及一个整数 amount +，表示总金额。计算并返回可以凑成总金额所需的 最少的硬币个数 +。如果没有任何一种硬币组合能组成总金额，返回 -1 +。你可以认为每种硬币的数量是无限的。

    +

    输入：coins = [1, 2, 5], S = 11

    +

    输出：3

    +

    解释：11 = 5 + 5 + 1

    +

    输入：coins = [2], S = 3

    +

    输出：-1

    +

    image-20210819174503970

    +

    \[ +f(x)=min\{f(x-c_1),f(x-c_2),...f(x-c_m)\}+1 +\]

    +

    如果\(x-c_i<0\)，则令\(f(x-c_i)=\infty\)这样就不会选这个\(f(x-c_i)\)了

    +

    如果\(x-c_i=0\),那么\(f(x-c_i)=0\)即\(f(0)=0\)

    +
    def change_coins():
        coins,S=[1,2,5],11    #拥有的硬币的种类，个数
        dp={}                 #定义一个dp的字典，记录到每一元钱，所需要的硬币个数
        temp=[]
        for i  in range(S+1):   #一直需要到11，所以这里是0-12
            for j in coins:
                if i-j==0:     #先判断这个x-c_i是不是等于0，如果是，令min{....}的数组中添加0
                    temp.append(0)
                elif i-j<0:    #在判断i-j是不是小于0，如果是，这说明这条路不行，于是令min{...}的...中添加一个数1000
                    temp.append(1000) 
                else:          #在其他的情况下都是满足的，那么可以按照上面的公式，在这个可能的结果中添加一个数为dp.get(i-j)
                    temp.append(dp.get(i-j))
            dp[i]=min(temp)+1  #dp[i]则应该为上面的一个数组中的一个数的最小值加一即min{[....]}+1
            temp=[]            #记得给数组归0
    #     print(dp)
        return dp
    change_coins()
    +

    现在我们已经知道硬币的最少组合为3，那我们如何得到是哪些硬币的组合

    +

    思路： +我们可以将S=11的最小硬币数是3分解一下，例如，硬币数是3，说明[1,2,5]中的三个可以组成，于是我们可以一个一个的遍历，看当11减去其中的一些数之后判断一下剩余的需要的最小硬币数是不是2，例如:11-1,然后:凑成10元的所需硬币数最小是2吗，是的话，跳出遍历，选择这一10继续分解，不是的话，继续遍历下面的，直到S=0说明已经遍历到0了，可以结束

    +

    如何得到硬币的组合呢（5，5，1）

    +
    def find_coins(S):
        dp=change_coins()    #调用上面的硬币交换得到dp数组
        coins=[1,2,5]       #硬币的种类为1,2,5
        n=dp.get(S)         #第一步先调出S的最小硬币数
        dp[0]=0             #给dp数组的0元素归0
        go,coin_cate=[],[]   #go数组可以记录整个换钱的过程，coin_cate可以看出每个过程所使用的硬币的金额
        while dp.get(S,0)-1>=0:     #当dp.get(S,0)-1=0时，说明S为非零且属于[1,2,5]
            for i in coins:         #从[1,2,5]中一个个取数
                if n-1==dp.get(S-i):    #如果有需要凑成S-i的钱的最小个数与S需要的最小个数只相差1，那么符合
                                        #取其中一种情况即可
                    go.append(S-i)      #把这个可以凑成的金额添加到路径里
                    coin_cate.append(i)  #把这次使用的种类添加到硬币的种类里
                    S=S-i                #给S从新赋值，让S=S-i，以便寻找下一轮循环
                    break                #只要找到满足条件的一个coins即可，不需要全部找到
            n=dp.get(S,0)
            if S==0:                     #如果S=0，说明整个分解可凑的钱程序已经已经走到需要凑0元的情况，
                                        #显然这种情况可以直接结束程序
                break
        print(go,coin_cate)
    find_coins(11)
    +

    Knapsack Problem

    +

    ​ +有10件货物要从甲地运送到乙地，每件货物的重量(单位:吨)和利润(单位:元)

    +

    如下表所示:

    +

    image-20210819174323036

    +

    ​ +由于只有--辆最大载重为30t的货车能用来运送货物，所以只能选择部分货物配送，要求确定运送哪些货物，使得运送这些货物的总利润最大。

    +

    思路：

    +

    ​ 有m件物品，第i件物品的利润为\(v_i\)重量为\(w_i\)背包的总重量为W.

    +

    原问题:在满足重量约束的条件下，将这m个物品选择性放入容量为W的背包所能获得的最大利润

    +

    子问题:在满足重量的约束条件下，将i(\(i\le +m\))件物品选择性放入容量为j(\(j \le +W\))的背包所获得的最大利润

    +

    状态分析:

    +

    ​ +我们要讲m件商品装进容量为W的背包，我们可以假设背包是从1,2,3,4...增大的容量，物品从第一次只装第一个产品，然后慢慢推广到前i个产品，所以DP表格其实是在背包容量为i的情况下，能装的礼物的最大价值

    +

    ​ +对于第一行来说，装的物品为第一个物品，所以只需要判断背包容量是否大于第一件物品的重量，若大于，则最大价值为第一件物品的价值

    +

    ​ +对于第一列来说，背包容量为1，装进前i件物品的最大价值，由于物品的重量始终为整数，所以在前i件物品里，我们要看有没有总量为1的物品，若没有，则什么也装不进去，那么最大价值为0，若有(可能有几个)，则去前i个产品中重量为1的所有物品中价值最大的那个为该点dp表的值

    +

    ​ 对于其它的列来说，需要用到状态转移方程，对于要求前\(i\)件物品装进容量为\(j\)的背包，在\(i-1\)的基础上只需要考虑到底装不装第\(i\)件物品，那么怎么考虑呢？要装第\(i\)件物品首先，第\(i\)件物品的重量必须小于背包的容量所以有: ​ +\(j-weight(i)>=0\)才去判断: \[ +max(dp[i-1][j],dp[i-1][j-weight[i]]+value[i]) +\]

    +

    它的意思是如果第i件物品装的下，那么就去判断不装这件物品和在没装这件物品，也就是dp[i-1][j-weight[i]]的最大价值，然后加上这件物品的价值。这样就可推出整个dp数组，而数组的最后一个元素，就是我们要求的最大价值

    +
    items=[(1,6,540),(2,3,200),(3,4,180),(4,5,350),(5,1,60),(6,2,150),(7,3,280),(8,5,450),(9,4,320),(10,2,120)]
    # 定义一个含有所有的价值的数组
    weight=30   # 定义背包的重量
    def bag_problem():
        dp=[]     #定义dp数组
        for i in range(len(items)):    #初始化dp数组
            dp.append([0]*weight)
        for i in range(len(items)):      #双重遍历开始填充数组
            for j in range(weight):
                if i==0 :
                    if j>=items[0][1]-1:    #背包大小大于等于物体的大小，物体大小为定值，则为items的价值
                        dp[i][j]=items[0][2]
                    else :
                        dp[i][j]=0          #如果背包太小，那就价值为0
                if j==0 :                   #探究第一列的值
                    if items[i][1]==1:
                        dp[i][j]=max(dp[i-1][0],items[i][2])      #如果可以装进去，前i个产品中重量为1的所有物品中价值最大
                    else:
                        dp[i][j]=dp[i-1][j]             #重量超过一的物品无法装入，直接用重量为1的物体价值最大的那个作为dp[i][j]
                else:                      #探究其它列
    #                 print(j)
                    if j+1-items[i][1]<0:   #如果背包转不下就只能是dp[i-1][j],相当于不装第i件
                        dp[i][j]=dp[i-1][j]
                    else:                   #其它情况判断背包产生的价值是否大于没装时候产生的价值
                        dp[i][j]=max(dp[i-1][j],dp[i-1][j-items[i][1]]+items[i][2])
        return dp
    #     for c in dp:
    #         print(c)
    for i in bag_problem():
        print(i)
    ]]>     - 电子 + coding     @@ -738,6 +652,92 @@ href="https://mp.weixin.qq.com/s/Etxi9erBTg0Y6Vt71Y4r9Q">同任务但不同domai

    Transform

    OpenAI ChatGPT（一）：十分钟读懂 Transformer - 知乎

    +]]> + + code + +     + + 专业英语 + /2023/06/05/English_profess/ + GANs

    +

    专业英语答辩

    + +
    +

    大家好，欢迎大家来到这里，今天我将为大家介绍一个用于图像翻译的新的技术，叫做cycle-gan,其是由AI华人青年学者Jun-Yan +Zhu主导的项目，在介绍这篇paper之前，我们先和大家介绍一些较为相近的领域。

    +
    +

    First

    +

    Hello everyone, welcome to come here, today I will introduce a new +technology for image translation, called cycle-gan, which is a project +led by young AI Chinese scholar Jun-Yan Zhu, in this paper Before that, +let's introduce some relatively similar fields to you.

    +
    +

    你们了解文心一言、或者是chatgpt，或许是由Google开发的bard吗？他们的共性是什么呢？没错，他们的共性就是都具有创造性，所谓的创造性，就是当你输入同一句话的时候，它能给出不同的结果，所以gpt的第一个单词就是Generative，但是CNN可不擅长生成式模型，当你给出同一个输入时，它更倾向于输出同一结果。

    +
    +

    Do you guys know Wenxinyiyan, or chatgpt, maybe bard developed by +Google? What do they have in common? Yes, what they have in common is +that they are all creative. The so-called creativity means that when you +input the same sentence, it can give different results, so the first +word of gpt is Generative, but CNN is not good at generative models. , +when you give the same input, it is more likely to output the same +result.

    +
    +

    另一个例子就是跨域识别问题，如何通过一个训练的模型，去泛化识别其它域的问题，这里就涉及到域适应，而gan就是用来解决这种问题的。

    +
    +

    Another example is the problem of cross-domain recognition. How to +generalize and recognize other domains through a trained model, here +involves domain adaptation, and gan is used to solve this problem.

    +
    +

    这是Gan的一个模型框架，主要是由生成器和判别器两部分组成，生成器用来生成内容，而判别器主要识别生成的内容是否是假的。生成器和判别器是两个模型，他们就如自然界一样捕食者与被捕食者共同进化。当判别器无法区分生成的内容是否为假，说明模型已经表现十分良好了

    +
    +

    This is a model framework of Gan, which is mainly composed of two +parts: the generator and the discriminator. The generator is used to +generate content, and the discriminator mainly identifies whether the +generated content is fake. The generator and the discriminator are two +models, and they co-evolve with the prey just like in nature. When the +discriminator cannot distinguish whether the generated content is fake +or not, it means that the model has performed very well

    +
    +

    Cycle-gan 使用了循环一致性，共需要四个模型，即两个生成模型GA->B, +GB->A,以及两个判别模型 +DA和DB，这就是cycle的由来，但是更加令人振奋人心的是：cycle-gan不需要配对的数据对进行训练，也就是说我们只需要给cycle-gan足够多的源域和目的域的数据，而不需要对其进行大量标签工作，它就会自动学习并且成功x +域到y域的转化规则，由于其涉及到两个域的双向转化，因而其迭代中使用的损失函数也是循环一致损失函数。

    +
    +

    Cycle-gan uses cycle consistency and requires a total of four models, +namely two generative models GA->B, GB->A, and two discriminative +models DA and DB. This is the origin of cycle, but it is even more +exciting What is popular is that cycle-gan does not require paired data +pairs for training, that is to say, we only need to give cycle-gan +enough data from the source domain and the target domain without a lot +of labeling work on it, and it will Automatically learn and successfully +convert the x domain to the y domain. Since it involves the two-way +conversion of the two domains, the loss function used in its iteration +is also a cycle consistent loss function.

    +

    second

    +
    +

    接下来给大家介绍一些cycle-gan应用:如视频增强领域，黑白视频变成彩色视频。或者是场景转化。或者是将抽象的画转化为一个具象的画如房屋建筑，这些都可以作为通信数据压缩，你可以试着一下发送方在网路上传送类似于色块一样的数据，它可能占用的带宽十分的小，当你在接收端受到这些色块时，再将其恢复出来。这样看起来是一个不错的视频压缩方法

    +
    +

    Next, I will introduce some cycle-gan applications: for example, in +the field of video enhancement, black-and-white video becomes color +video. Or scene transformation. Or convert an abstract painting into a +concrete painting such as a building, these can be used as communication +data compression, you can try the sender to transmit data similar to +color blocks on the network, it may take up a lot of bandwidth Small, +when you get these color patches at the receiving end, bring them back. +This looks like a good way to compress video

    +

    Third

    +

    The third part is sentence analysis，

    +

    The meaning of the first sentence is +“此外，在实践中，我们发现很难优化对抗目标隔离：标准程序通常会导致众所周知的模式崩溃问题，其中所有输入图像都映射到相同的输出图像，优化无法取得进展 +[15]。

    +

    ”。

    +

    The second sentence +means：“我们还与以前依赖于手动定义的样式和内容分解或共享嵌入函数的方法进行了比较，并表明我们的方法优于这些基线。”。

    +

    The third part is sentence analysis +“图像到图像转换的想法至少可以追溯到 Hertzmann 等人的图像类比 +[19]，他们在单个输入输出训练图像对上采用非参数纹理模型 [10]。”

    +

    Here are some references. thanks for listening！

    ]]>     code @@ -771,7 +771,86 @@ alt="被删除视频" /> 总之，十分感谢那些和我一起走过这段道路的小伙伴，谢谢你们的付出，也谢谢那些帮助我们完成实践课的各位同学，就如视频所说，你们是冬天里的暖阳😉😉😉😉。

    ]]> - 思想觉悟 + 思想觉悟 + +     + + Pointer + /2021/09/03/Point/ + Review the knowledge of pointers

    + +

    Pointer Category

    +
      +

    • Pointer point the constant:

      +
      const char *name = "chen"    //statement a pointer point a constant
      +

      because using const,so the Pointer can't change variable +in the address which it point ,so the statement as follows is incorrect +:

      +
      name[3]='a'					//incorrect,pointer "name" can't change constant
      +

      but name is a normal pointer ,so it could change the items it +point,statement as follows are correct:

      +
      name = 'zhang'				//change the address the pointer point ,correct
      +

      Also,Even you have changed your string you point ,you still can't +change the string, Please somebody tell me why ,Thank you !

      +
      name[3]='y'					//incorrect,but I don't know why!
      • +

    • Constant Pointer

      +

      A pointer can't change the address it point ,but it still can change +the content it point,example:

      +
      char *const name ="chen";     //define a constant pointer
      name[3] = 'a';					//correct ,it can change the constent of pointer
      name = "zhang";					//incorrect ,it can't change the address it points
      • +

    • Constant Pointer points to constant

      +

      A constant pointer points a constant ,the address pointer point is +unchangeable and the content of address is unchangeable,example :

      +
      const char *const name="chen";	//define a constant pointer point the constant
      name[3] = 'q';					//incorrect ,the constant is unchangeable
      name ='ninglang';				//incorrect ,the address pointed is unchangeable
      • +

    • Const

      +

      Using a const to define a integer variable ,the keyword +omitted is acceptable the definition as following is same:

      +
      const int LIMITS = 100;
      const LIMITS = 100;
      +

      formal parameters also can be describe by const,for +example:

      +
      int MAX(const int*ptr)
      +

      the method promise the array can't be changed ,only be read.

      • +
    +

    Pointer array

    +
    #include<stdio.h>

    int main(void){
        char *arr[3]={'abc','def','ghi'};
        char *pArr = arr[0];
        printf("The string array arr's element :");
        for(int index=0;index<3;index++){
            printf("%s",arr[index]);
        }
        printf("\n");
        printf("The string arr's first element's every element:");
        for(int index = 0;index<3;index++){
            printf("%c",*(pArr+index));
        }
        printf("\n");
        return 0;
    }
    +

    in fact , you see the definition of Pointer array ,It is like as +follows:

    +
    char *arr[3]={'abc','def','ghi'};
    +
    char *pChar1 = 'abc',*pChar2 = 'def',*pChar3='ghi'
    char *arr[3] = {pChar1,pChar2,pChar3};
    +

    At the same time :

    +
    arr[0] = pChar;   //the arr first element is the pointer pChar
    +

    and the pChar is pointing the 'abc''s first element 'a', +so we can use the code to print 'a'

    +
    printf("%c",pChar[0]);   //print 'a'
    // print'a','b','c'
    for(int i = 0;i<3;i++){
        printf("%c ",pChar[i]);
    }
    +

    Pointer Function

    +
    int fun(int x,int y);			//normal function return integers
    +

    This function declaration is normal ,but There are some difference in +next function declaration

    +
    int *fun(int x,int y)
    +

    This function declaration is pointer function ,the return is a +pointer to int ,This is an address

    +

    Pointer To Function

    +

    To state a pointer to function ,which is a Pointer pointing function +.declaration form:

    +
    int (*fun)(int x,int y)
    +

    There are two ways to assign values to pointer variables

    +
    fun = &function;
    fun = function;
    +

    There are also two ways to call pointer to function

    +
    x=(*fun)();
    x=fun();
    +

    Example:

    +
    #include<stdio.h>
    #include<iostream>
    using namespace std;
    int add(int x,int y){
    	return x+y;
    }

    int sub(int x,int y){
    	return x-y;
    }

    int (*fun)(int x,int y);
    int main(){
    	//first kind 
    	fun = add;
    	cout<<"(*fun)(1,2)="<<(*fun)(1,2)<<endl;
        //second kind
    	fun = &sub;
    	cout<<"(*fun)(5,3)="<<(*fun)(5,3)<<" "<<fun(5,3);
    	
    	
    	return 0;
    	
    }
    +

    New and Delete

    +

    operation new can get a space from heap and return the +pointer to point the first address of the memory,and delete +can free the space

    +
    int *p;
    p = new int ; //new dynamically allocate an integer memory space,assign the first address to pointer variable


    delete p;   	//free the space allocated by new
    +

    new assign space for multidimensional array:

    +
    int i = 3;
    int *pi = new int[3][4];
    +

    new assign space with initial value:

    +
    #include<iostream>
    using namespace std;
    int main(){
    	int *p;
    	p = new int(99);      //initial value
    	cout<<*p;
    	delete p;
    	return 0;
    }
    +

    Malloc && Free get space

    +]]>     + + coding     @@ -937,85 +1016,6 @@ figure,see whether it is overfit or not ? Neural Network - - Pointer - /2021/09/03/Point/ - Review the knowledge of pointers

    - -

    Pointer Category

    -
      -

    • Pointer point the constant:

      -
      const char *name = "chen"    //statement a pointer point a constant
      -

      because using const,so the Pointer can't change variable -in the address which it point ,so the statement as follows is incorrect -:

      -
      name[3]='a'					//incorrect,pointer "name" can't change constant
      -

      but name is a normal pointer ,so it could change the items it -point,statement as follows are correct:

      -
      name = 'zhang'				//change the address the pointer point ,correct
      -

      Also,Even you have changed your string you point ,you still can't -change the string, Please somebody tell me why ,Thank you !

      -
      name[3]='y'					//incorrect,but I don't know why!
      • -

    • Constant Pointer

      -

      A pointer can't change the address it point ,but it still can change -the content it point,example:

      -
      char *const name ="chen";     //define a constant pointer
      name[3] = 'a';					//correct ,it can change the constent of pointer
      name = "zhang";					//incorrect ,it can't change the address it points
      • -

    • Constant Pointer points to constant

      -

      A constant pointer points a constant ,the address pointer point is -unchangeable and the content of address is unchangeable,example :

      -
      const char *const name="chen";	//define a constant pointer point the constant
      name[3] = 'q';					//incorrect ,the constant is unchangeable
      name ='ninglang';				//incorrect ,the address pointed is unchangeable
      • -

    • Const

      -

      Using a const to define a integer variable ,the keyword -omitted is acceptable the definition as following is same:

      -
      const int LIMITS = 100;
      const LIMITS = 100;
      -

      formal parameters also can be describe by const,for -example:

      -
      int MAX(const int*ptr)
      -

      the method promise the array can't be changed ,only be read.

      • -
    -

    Pointer array

    -
    #include<stdio.h>

    int main(void){
        char *arr[3]={'abc','def','ghi'};
        char *pArr = arr[0];
        printf("The string array arr's element :");
        for(int index=0;index<3;index++){
            printf("%s",arr[index]);
        }
        printf("\n");
        printf("The string arr's first element's every element:");
        for(int index = 0;index<3;index++){
            printf("%c",*(pArr+index));
        }
        printf("\n");
        return 0;
    }
    -

    in fact , you see the definition of Pointer array ,It is like as -follows:

    -
    char *arr[3]={'abc','def','ghi'};
    -
    char *pChar1 = 'abc',*pChar2 = 'def',*pChar3='ghi'
    char *arr[3] = {pChar1,pChar2,pChar3};
    -

    At the same time :

    -
    arr[0] = pChar;   //the arr first element is the pointer pChar
    -

    and the pChar is pointing the 'abc''s first element 'a', -so we can use the code to print 'a'

    -
    printf("%c",pChar[0]);   //print 'a'
    // print'a','b','c'
    for(int i = 0;i<3;i++){
        printf("%c ",pChar[i]);
    }
    -

    Pointer Function

    -
    int fun(int x,int y);			//normal function return integers
    -

    This function declaration is normal ,but There are some difference in -next function declaration

    -
    int *fun(int x,int y)
    -

    This function declaration is pointer function ,the return is a -pointer to int ,This is an address

    -

    Pointer To Function

    -

    To state a pointer to function ,which is a Pointer pointing function -.declaration form:

    -
    int (*fun)(int x,int y)
    -

    There are two ways to assign values to pointer variables

    -
    fun = &function;
    fun = function;
    -

    There are also two ways to call pointer to function

    -
    x=(*fun)();
    x=fun();
    -

    Example:

    -
    #include<stdio.h>
    #include<iostream>
    using namespace std;
    int add(int x,int y){
    	return x+y;
    }

    int sub(int x,int y){
    	return x-y;
    }

    int (*fun)(int x,int y);
    int main(){
    	//first kind 
    	fun = add;
    	cout<<"(*fun)(1,2)="<<(*fun)(1,2)<<endl;
        //second kind
    	fun = &sub;
    	cout<<"(*fun)(5,3)="<<(*fun)(5,3)<<" "<<fun(5,3);
    	
    	
    	return 0;
    	
    }
    -

    New and Delete

    -

    operation new can get a space from heap and return the -pointer to point the first address of the memory,and delete -can free the space

    -
    int *p;
    p = new int ; //new dynamically allocate an integer memory space,assign the first address to pointer variable


    delete p;   	//free the space allocated by new
    -

    new assign space for multidimensional array:

    -
    int i = 3;
    int *pi = new int[3][4];
    -

    new assign space with initial value:

    -
    #include<iostream>
    using namespace std;
    int main(){
    	int *p;
    	p = new int(99);      //initial value
    	cout<<*p;
    	delete p;
    	return 0;
    }
    -

    Malloc && Free get space

    -]]>     - - coding - -     保研注意事项 /2023/06/13/Postgraduate/ @@ -1094,6 +1094,63 @@ href="https://www.piwheels.org/project/opencv-python/">opencv-python下载 
    apt-get install axel

    下载方式

    axel 参数 文件下载地址
    常用可选参数：
    -s   设置最大下载速度，如果限制到512KB/s，则填写512000
    -n   指定连接数
    -o   指定另存为目录，或者指定的目录+文件名
    -H   指定header
    -U 指定useragent
    -q   静默模式
    -a   更改默认进度条样式

    eg:
    axel -n 30 http://archive.cloudera.com/cm5/cm/5/cloudera-manager-centos7-cm5.15.2_x86_64.tar.gz
    +]]> + + coding + +     + + Qt + /2021/09/20/Qt1/ + Qt问题总汇

    + +

    信号和槽

    +

    连接函数：connect

    +
    connect(信号发送者，发送的信号（函数的地址），信号接受者，处理的槽函数（函数的地址）);
    connect(Button,&QpushButton::clicked,this,&Qwidget::close);
    +

    松散耦合：发送端和接受端的松散耦合

    +

    自定义槽函数和信号

    +
      +
    • signal只能声明，不能定义，写在发送信号的类的signals中，返回值是void
      • +
    • slot需要声明，需要在cpp文件中定义，写在public slots文件中，返回值是void
      • +
    +
    class.h
    public slots:
        // slots function area or declaration in public
        //return is void,need declaration ,and realize.
        void treat();
    };


    class.cpp
    void Studnet::treat(){
        qDebug()<<"treat!";
    }
    +
    signals:
        //custom signals
        //return is void,only declaration ,Needn't realize
        void hungry();
    +

    定义槽和信号后，需要定义触发函数

    +
    weidget:
    	void classover();
    	void classover(){
            emit zt->hungry();
        }
    +

    要先定义connect再调用classover。

    +

    信号的重载

    +

    信号函数和槽函数直接重载时，会因为二义性而导致程序无法编译，于是我们需要用函数指针来代替直接给地址，方法如下:

    +
    void(Teacher:: *teachersignal)(QString)=&Teacher::hungry;
    void(Studnet:: *studentslot)(QString) = &Studnet::treat;    

    connect(zt,teachersignal::hungry,st,studentslot);
    +
      +
    • 问题：这里的两个函数指针是如何定义的？？？
      • +
    • 答：
      • +
    +

    Qstring 转char *

    +
    Qstring.toUtf8().data()  //先转utf8，再转char*
    +

    信号连接信号

    +
    connect(btn,&QPushButton::clicked,zt,teachersignal2);
    +

    直接将两个信号用connect相连

    +
      +

    • 断开信号 disconnect

      • +

    • 多个信号一个槽

      • +

    • 多个槽连接一个信号

      • +

    • 信号和槽的参数类型必须一一对应，信号参数个数可以大于槽函数的参数个数

      • +
    +

    lambda函数

    +
    //connect 一般使用方法
    connect(信号发送者，发送的信号（函数的地址），信号接受者，处理的槽函数（函数的地址）);

    //lambda 使用的方式
    connect(btn3,&QPushButton::clicked,this,[=](){
            btn3->move(200,100);});
    //可以省略this
    connect(btn3,&QPushButton::clicked,[=](){
            btn3->move(200,100);});
    +
      +
    • 问：为什么lambda的函数不像之前的函数一样，需要取地址符&.
      • +
    • 答：可以不加取地址符，但是早期Qt并不支持.
      • +
    +

    模态与非模态

    +

    模态

    +
    connect(ui->actionnew,&QAction::triggered,[=](){
        QDialog dlg(this);
        dlg.resize(200,100);
        dlg.exec();  //对话框窗口保持
        qDebug()<<"modal dialog!";
    +

    非模态

    +
    [=](){QDialog dig2(this);
             dig2.show();  //无法保持，一闪而过
            }
    QDialog *dig2 =new QDialog(this);
       dig2->show();	//可以保持(堆区)
    +
      +
    • 问：指针调用和对象调用为什么会出现不一样的结果？
      • +
    • 答：
      • +
    ]]>     coding @@ -1217,73 +1274,6 @@ href="https://pypi.org/project/torch/1.8.0/#modal-close">torch-wheel下载 Code     - - Qt - /2021/09/20/Qt1/ - Qt问题总汇

    - -

    信号和槽

    -

    连接函数：connect

    -
    connect(信号发送者，发送的信号（函数的地址），信号接受者，处理的槽函数（函数的地址）);
    connect(Button,&QpushButton::clicked,this,&Qwidget::close);
    -

    松散耦合：发送端和接受端的松散耦合

    -

    自定义槽函数和信号

    -
      -
    • signal只能声明，不能定义，写在发送信号的类的signals中，返回值是void
      • -
    • slot需要声明，需要在cpp文件中定义，写在public slots文件中，返回值是void
      • -
    -
    class.h
    public slots:
        // slots function area or declaration in public
        //return is void,need declaration ,and realize.
        void treat();
    };


    class.cpp
    void Studnet::treat(){
        qDebug()<<"treat!";
    }
    -
    signals:
        //custom signals
        //return is void,only declaration ,Needn't realize
        void hungry();
    -

    定义槽和信号后，需要定义触发函数

    -
    weidget:
    	void classover();
    	void classover(){
            emit zt->hungry();
        }
    -

    要先定义connect再调用classover。

    -

    信号的重载

    -

    信号函数和槽函数直接重载时，会因为二义性而导致程序无法编译，于是我们需要用函数指针来代替直接给地址，方法如下:

    -
    void(Teacher:: *teachersignal)(QString)=&Teacher::hungry;
    void(Studnet:: *studentslot)(QString) = &Studnet::treat;    

    connect(zt,teachersignal::hungry,st,studentslot);
    -
      -
    • 问题：这里的两个函数指针是如何定义的？？？
      • -
    • 答：
      • -
    -

    Qstring 转char *

    -
    Qstring.toUtf8().data()  //先转utf8，再转char*
    -

    信号连接信号

    -
    connect(btn,&QPushButton::clicked,zt,teachersignal2);
    -

    直接将两个信号用connect相连

    -
      -

    • 断开信号 disconnect

      • -

    • 多个信号一个槽

      • -

    • 多个槽连接一个信号

      • -

    • 信号和槽的参数类型必须一一对应，信号参数个数可以大于槽函数的参数个数

      • -
    -

    lambda函数

    -
    //connect 一般使用方法
    connect(信号发送者，发送的信号（函数的地址），信号接受者，处理的槽函数（函数的地址）);

    //lambda 使用的方式
    connect(btn3,&QPushButton::clicked,this,[=](){
            btn3->move(200,100);});
    //可以省略this
    connect(btn3,&QPushButton::clicked,[=](){
            btn3->move(200,100);});
    -
      -
    • 问：为什么lambda的函数不像之前的函数一样，需要取地址符&.
      • -
    • 答：可以不加取地址符，但是早期Qt并不支持.
      • -
    -

    模态与非模态

    -

    模态

    -
    connect(ui->actionnew,&QAction::triggered,[=](){
        QDialog dlg(this);
        dlg.resize(200,100);
        dlg.exec();  //对话框窗口保持
        qDebug()<<"modal dialog!";
    -

    非模态

    -
    [=](){QDialog dig2(this);
             dig2.show();  //无法保持，一闪而过
            }
    QDialog *dig2 =new QDialog(this);
       dig2->show();	//可以保持(堆区)
    -
      -
    • 问：指针调用和对象调用为什么会出现不一样的结果？
      • -
    • 答：
      • -
    -]]>     - - coding - -     - - 学业生涯规划指导经验交流贴 - /2023/10/31/Study%20exchange%20meeting/ - 欢迎交流

    - -]]>     - - 学习 - -     DSP /2022/03/14/Signals%20and%20Systems/ @@ -1317,6 +1307,16 @@ href="https://pypi.org/project/torch/1.8.0/#modal-close">torch-wheel下载 电子 + + 学业生涯规划指导经验交流贴 + /2023/10/31/Study%20exchange%20meeting/ + 欢迎交流

    + +]]>     + + 学习 + +     出租车载客模型 /2021/08/15/Taxi%20passenger%20model/ @@ -1782,7 +1782,89 @@ alt="image-20240302141718235" /> 
    wget https://developer.download.nvidia.com/compute/cuda/repos/wsl-ubuntu/x86_64/cuda-wsl-ubuntu.pin

    sudo mv cuda-wsl-ubuntu.pin /etc/apt/preferences.d/cuda-repository-pin-600

    wget https://developer.download.nvidia.com/compute/cuda/11.8.0/local_installers/cuda-repo-wsl-ubuntu-11-8-local_11.8.0-1_amd64.deb

    sudo dpkg -i cuda-repo-wsl-ubuntu-11-8-local_11.8.0-1_amd64.deb

    sudo cp /var/cuda-repo-wsl-ubuntu-11-8-local/cuda-*-keyring.gpg /usr/share/keyrings/

    sudo apt-get update

    sudo apt-get -y install cuda
    ]]> - Windows + Windows + +     + + 评价类数学模型总结 + /2022/01/22/common_model/ + 小小总结，希望以后对自己有帮助

    + +

    权重系数确定的方法

    +

    题设：n个评价对象，m个评价指标观测值为 \[ +a_{ij}\quad(i=1,2,...n;j=1,2,..,m) +\]

    +

    \[ +\begin{bmatrix}a_{11} & a_{12}&...&a_{1,m}\\\\a_{21} & +a_{22}&...&a_{2m}\\ \vdots&...&...&\\a_{n1} & +a_{n2}&...&a_{nm}\end{bmatrix} +\]

    +

    均方差法

    +

    \[ +\mu_j=\frac{1}{n}\sum_{i=1}^{n}a_{ij}\qquad +s_j=\sqrt{\frac{1}{n}(a_{ij}-\mu_j)^2}\\ +\]

    +

    \[ +\begin{bmatrix}a_{11}\\a_{21}\\\vdots\\a_{n1}\end{bmatrix}\cdots\begin{bmatrix}a_{1m}\\a_{2m}\\\vdots\\a_{nm}\end{bmatrix}\longrightarrow\begin{bmatrix}\mu_1&\cdots\mu_m\end{bmatrix}\longrightarrow +\begin{bmatrix}s_1&\cdots&s_m\end{bmatrix}\\ +\]

    +

    \[ +w_j=\frac{s_j}{\sum_{k=1}^{m}s_k}(j=1,2,3,4...m)\\ +\]

    +

    \[ +\begin{bmatrix}w_1& w_2&\cdots w_m\end{bmatrix} +\]

    +

    极差法

    +

    \[ +r_{j}=\max _{1 \leq i<k \leq n}\left\{\left|a_{i j}-a_{k +j}\right|\right\}(j=1,2, \cdots, m)\\ +\]

    +

    \[ +\max_{every +element}\begin{bmatrix}rand(a_{i1}-a_{k1})&\cdots&rand(a_{ij}-a_{kj})\end{bmatrix}\longrightarrow\begin{bmatrix}r_1&r_2&\cdots&r_m\end{bmatrix} +\]

    +

    所以第\(j\)项指标的权重系数为 \[ +w_{j}=\frac{s_{j}}{\sum_{l=1}^{m} r_{k}}(j=1,2, \cdots, m) +\]

    +

    熵值法

    +

    特征比重：

    +

    在\[\mu_j=\sum_{i=1}^{n} a_{i +j}>0\],第\(j\)项指标的特征比重为 \[ +p_{i j}=\frac{a_{i j}}{\sum_{i=1}^{n} a_{i j}}(i=1,2, \cdots, n ; j=1,2, +\cdots, m) +\]

    +

    \[ +\begin{bmatrix}a_{11}\\a_{21}\\\vdots\\a_{n1}\end{bmatrix}\cdots\begin{bmatrix}a_{1m}\\a_{2m}\\\vdots\\a_{nm}\end{bmatrix}\longrightarrow\begin{bmatrix}\mu_1&\cdots\mu_m\end{bmatrix}\longrightarrow\begin{bmatrix}p_{11}&\cdots&p_{1m}\\p_{21}&\cdots&p_{2m}\\\vdots&\cdots&\\p_{n1}&\cdots&p_{nm}\end{bmatrix} +\]

    +

    第\(j\)项的熵值为： \[ +e_{j}=-\frac{1}{\ln n} \sum_{i=1}^{n} p_{i j} \ln p_{i j}(j=1,2, \cdots, +m) +\]

    +

    \[ +\begin{bmatrix}p_{11}&\cdots&p_{1m}\\p_{21}&\cdots&p_{2m}\\\vdots&\cdots&\\p_{n1}&\cdots&p_{nm}\end{bmatrix}\longrightarrow\begin{bmatrix}e_1&\cdots&e_m\end{bmatrix} +\]

    +

    不难看出，如果第\(j\)项指标的观测值差异越大，熵值越小；反之，熵值越大。

    +

    计算第\(j\)项指标的差异系数为 \[ +g_{j}=1-e_{j}(j=1,2, \cdots, m) +\] 如果第项指标的观测值差异越大，则差异系数\(g\)就越大，第\(j\)项指标也就越重要。

    +

    第\(j\)项的权重系数为 \[ +w_{j}=\frac{g_{j}}{\sum_{k=1}^{m} g_{k}}(j=1,2, \cdots, m) +\] 参考文章:

    +

    熵的定义，信息熵

    +]]>     + + Math model     @@ -2048,88 +2130,6 @@ class="math inline">\(O(1)\) coding - - 评价类数学模型总结 - /2022/01/22/common_model/ - 小小总结，希望以后对自己有帮助

    - -

    权重系数确定的方法

    -

    题设：n个评价对象，m个评价指标观测值为 \[ -a_{ij}\quad(i=1,2,...n;j=1,2,..,m) -\]

    -

    \[ -\begin{bmatrix}a_{11} & a_{12}&...&a_{1,m}\\\\a_{21} & -a_{22}&...&a_{2m}\\ \vdots&...&...&\\a_{n1} & -a_{n2}&...&a_{nm}\end{bmatrix} -\]

    -

    均方差法

    -

    \[ -\mu_j=\frac{1}{n}\sum_{i=1}^{n}a_{ij}\qquad -s_j=\sqrt{\frac{1}{n}(a_{ij}-\mu_j)^2}\\ -\]

    -

    \[ -\begin{bmatrix}a_{11}\\a_{21}\\\vdots\\a_{n1}\end{bmatrix}\cdots\begin{bmatrix}a_{1m}\\a_{2m}\\\vdots\\a_{nm}\end{bmatrix}\longrightarrow\begin{bmatrix}\mu_1&\cdots\mu_m\end{bmatrix}\longrightarrow -\begin{bmatrix}s_1&\cdots&s_m\end{bmatrix}\\ -\]

    -

    \[ -w_j=\frac{s_j}{\sum_{k=1}^{m}s_k}(j=1,2,3,4...m)\\ -\]

    -

    \[ -\begin{bmatrix}w_1& w_2&\cdots w_m\end{bmatrix} -\]

    -

    极差法

    -

    \[ -r_{j}=\max _{1 \leq i<k \leq n}\left\{\left|a_{i j}-a_{k -j}\right|\right\}(j=1,2, \cdots, m)\\ -\]

    -

    \[ -\max_{every -element}\begin{bmatrix}rand(a_{i1}-a_{k1})&\cdots&rand(a_{ij}-a_{kj})\end{bmatrix}\longrightarrow\begin{bmatrix}r_1&r_2&\cdots&r_m\end{bmatrix} -\]

    -

    所以第\(j\)项指标的权重系数为 \[ -w_{j}=\frac{s_{j}}{\sum_{l=1}^{m} r_{k}}(j=1,2, \cdots, m) -\]

    -

    熵值法

    -

    特征比重：

    -

    在\[\mu_j=\sum_{i=1}^{n} a_{i -j}>0\],第\(j\)项指标的特征比重为 \[ -p_{i j}=\frac{a_{i j}}{\sum_{i=1}^{n} a_{i j}}(i=1,2, \cdots, n ; j=1,2, -\cdots, m) -\]

    -

    \[ -\begin{bmatrix}a_{11}\\a_{21}\\\vdots\\a_{n1}\end{bmatrix}\cdots\begin{bmatrix}a_{1m}\\a_{2m}\\\vdots\\a_{nm}\end{bmatrix}\longrightarrow\begin{bmatrix}\mu_1&\cdots\mu_m\end{bmatrix}\longrightarrow\begin{bmatrix}p_{11}&\cdots&p_{1m}\\p_{21}&\cdots&p_{2m}\\\vdots&\cdots&\\p_{n1}&\cdots&p_{nm}\end{bmatrix} -\]

    -

    第\(j\)项的熵值为： \[ -e_{j}=-\frac{1}{\ln n} \sum_{i=1}^{n} p_{i j} \ln p_{i j}(j=1,2, \cdots, -m) -\]

    -

    \[ -\begin{bmatrix}p_{11}&\cdots&p_{1m}\\p_{21}&\cdots&p_{2m}\\\vdots&\cdots&\\p_{n1}&\cdots&p_{nm}\end{bmatrix}\longrightarrow\begin{bmatrix}e_1&\cdots&e_m\end{bmatrix} -\]

    -

    不难看出，如果第\(j\)项指标的观测值差异越大，熵值越小；反之，熵值越大。

    -

    计算第\(j\)项指标的差异系数为 \[ -g_{j}=1-e_{j}(j=1,2, \cdots, m) -\] 如果第项指标的观测值差异越大，则差异系数\(g\)就越大，第\(j\)项指标也就越重要。

    -

    第\(j\)项的权重系数为 \[ -w_{j}=\frac{g_{j}}{\sum_{k=1}^{m} g_{k}}(j=1,2, \cdots, m) -\] 参考文章:

    -

    熵的定义，信息熵

    -]]>     - - Math model - -     Docker-ubuntu安装ssh /2024/01/22/docker-ubuntu-ssh%E5%AE%89%E8%A3%85/ @@ -2349,68 +2349,6 @@ verbose详细显示，-f file文件属性）

    3.进入onlyoffice修改etc/onlyoffice/documentserver/default.json，修改如下

    "rejectUnauthorized": false



    "allowPrivateIPAddress": true,
    "allowMetaIPAddress": true

    重启docker

    -]]> - - Code - -     - - ikuai搭建seafile-docker - /2024/01/20/seafile6.3.4%E7%88%B1%E5%BF%AB%E7%B3%BB%E7%BB%9F%E6%90%AD%E5%BB%BA%E6%95%99%E7%A8%8B/ - 这是一篇有关使用ikuai搭建6.3.4的博客，并且实现了ipv6的访问

    - -

    step1： 安装seafile-docker

    -

    下载seafileltd/seafile:latest镜像

    -
    - - -
    -

    在容器设置中挂载目录

    -
      -
    • /shared
      • -
    -

    如下环境变量设置账号和密码

    -
      -
    • SEAFILE_ADMIN_EMAIL
      • -
    • SEAFILE_ADMIN_PASSWORD
      • -
    -

    step2：安装 iputils-ping

    -

    因为docker中的ipv6如果不往外界发出信号，路由是无法知道该容器的ipv6地址,所以需要安装ping工具每隔一段时间不断发包，表示心跳

    -

    1.更新apt包

    -
    apt update
    -

    2.安装iputils-ping

    -
    apt-get install -y iputils-ping
    -

    3.测试ping百度

    -
    ping -6 -c 1 www.baidu.com
    -

    3.编写/root/script/ping.sh

    -
    while true; do
        ping -c 1 -6  www.baidu.com > /dev/null
        sleep 15
    done &
    -

    4.修改ping.sh为可执行文件

    -
    chmod +x /root/script/ping.sh
    -

    5.测试脚本执行情况：如下执行成功

    -

    6.修改自启动脚本

    -

    在/root/.bashrc中追加

    -
    if [ -f /root/script/ping.sh ]; then
          /root/script/ping.sh
    fi
    -

    一般而言，由于seafile不自动开bash，因此，建议将上述加入.bashrc加入到seafile-server-latest/seafile.sh中，添加到echo "Seafile server started"的前面.

    -

    step3：设置nginx反向代理

    -

    1.创建/etc/nginx/conf.d/seafile.conf，内容如下

    -
    server {
        listen [::]:80;
        server_name seafile.ninglang.fun;

        proxy_set_header X-Forwarded-For $remote_addr;

        location / {
             proxy_pass         http://127.0.0.1:8000;
             proxy_set_header   Host $host;
             proxy_set_header   X-Real-IP $remote_addr;
             proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
             proxy_set_header   X-Forwarded-Host $server_name;
             proxy_read_timeout  1200s;

             # used for view/edit office file via Office Online Server
             client_max_body_size 0;

             access_log      /var/log/nginx/seahub.access.log;
             error_log       /var/log/nginx/seahub.error.log;
        }


        location /seafhttp {
            rewrite ^/seafhttp(.*)$ $1 break;
            proxy_pass http://127.0.0.1:8082;
            client_max_body_size 0;
            proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;

            proxy_connect_timeout  36000s;
            proxy_read_timeout  36000s;
            proxy_send_timeout  36000s;

            send_timeout  36000s;
        }
    	
    	location /seafdav {
            fastcgi_pass    127.0.0.1:8080;
            fastcgi_param   SCRIPT_FILENAME     $document_root$fastcgi_script_name;
            fastcgi_param   PATH_INFO           $fastcgi_script_name;
            fastcgi_param   SERVER_PROTOCOL     $server_protocol;
            fastcgi_param   QUERY_STRING        $query_string;
            fastcgi_param   REQUEST_METHOD      $request_method;
            fastcgi_param   CONTENT_TYPE        $content_type;
            fastcgi_param   CONTENT_LENGTH      $content_length;
            fastcgi_param   SERVER_ADDR         $server_addr;
            fastcgi_param   SERVER_PORT         $server_port;
            fastcgi_param   SERVER_NAME         $server_name;
            client_max_body_size 0;
            proxy_connect_timeout  36000s;
            proxy_read_timeout  36000s;
            proxy_send_timeout  36000s;
            send_timeout  36000s;

            # This option is only available for Nginx >= 1.8.0. See more details below.
            proxy_request_buffering off;
            access_log      /var/log/nginx/seafdav.access.log;
            error_log       /var/log/nginx/seafdav.error.log;
        }
        
    }

    -

    2.测试文件格式正常

    -
    nginx -t

    #nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
    #nginx: configuration file /etc/nginx/nginx.conf test is successful
    -

    重启docker容器

    -

    step4：设置seafile

    -

    修改SERVICE_URL和FILE_SERVER_ROOT

    -

    SERVICE_URL:http://seafile.ninglang.fun

    -

    FILE_SERVER_ROOT:http://seafile.ninglang.fun/seafhttp

    -

    step5：设置seafdav

    -

    设置/conf/seafdav.conf中为

    -
    enabled = true
    port = 8080
    fastcgi = true
    share_name = /seafdav
    -

    在手机端设置

    -

    网络地址:seafile.ninglang.fun/seafdav

    -

    账号密码如实填写

    ]]>     Code @@ -2546,6 +2484,68 @@ href="https://blog.csdn.net/m0_51961114/article/details/120699238">(34条消息) code     + + ikuai搭建seafile-docker + /2024/01/20/seafile6.3.4%E7%88%B1%E5%BF%AB%E7%B3%BB%E7%BB%9F%E6%90%AD%E5%BB%BA%E6%95%99%E7%A8%8B/ + 这是一篇有关使用ikuai搭建6.3.4的博客，并且实现了ipv6的访问

    + +

    step1： 安装seafile-docker

    +

    下载seafileltd/seafile:latest镜像

    +
    + + +
    +

    在容器设置中挂载目录

    +
      +
    • /shared
      • +
    +

    如下环境变量设置账号和密码

    +
      +
    • SEAFILE_ADMIN_EMAIL
      • +
    • SEAFILE_ADMIN_PASSWORD
      • +
    +

    step2：安装 iputils-ping

    +

    因为docker中的ipv6如果不往外界发出信号，路由是无法知道该容器的ipv6地址,所以需要安装ping工具每隔一段时间不断发包，表示心跳

    +

    1.更新apt包

    +
    apt update
    +

    2.安装iputils-ping

    +
    apt-get install -y iputils-ping
    +

    3.测试ping百度

    +
    ping -6 -c 1 www.baidu.com
    +

    3.编写/root/script/ping.sh

    +
    while true; do
        ping -c 1 -6  www.baidu.com > /dev/null
        sleep 15
    done &
    +

    4.修改ping.sh为可执行文件

    +
    chmod +x /root/script/ping.sh
    +

    5.测试脚本执行情况：如下执行成功

    +

    6.修改自启动脚本

    +

    在/root/.bashrc中追加

    +
    if [ -f /root/script/ping.sh ]; then
          /root/script/ping.sh
    fi
    +

    一般而言，由于seafile不自动开bash，因此，建议将上述加入.bashrc加入到seafile-server-latest/seafile.sh中，添加到echo "Seafile server started"的前面.

    +

    step3：设置nginx反向代理

    +

    1.创建/etc/nginx/conf.d/seafile.conf，内容如下

    +
    server {
        listen [::]:80;
        server_name seafile.ninglang.fun;

        proxy_set_header X-Forwarded-For $remote_addr;

        location / {
             proxy_pass         http://127.0.0.1:8000;
             proxy_set_header   Host $host;
             proxy_set_header   X-Real-IP $remote_addr;
             proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;
             proxy_set_header   X-Forwarded-Host $server_name;
             proxy_read_timeout  1200s;

             # used for view/edit office file via Office Online Server
             client_max_body_size 0;

             access_log      /var/log/nginx/seahub.access.log;
             error_log       /var/log/nginx/seahub.error.log;
        }


        location /seafhttp {
            rewrite ^/seafhttp(.*)$ $1 break;
            proxy_pass http://127.0.0.1:8082;
            client_max_body_size 0;
            proxy_set_header   X-Forwarded-For $proxy_add_x_forwarded_for;

            proxy_connect_timeout  36000s;
            proxy_read_timeout  36000s;
            proxy_send_timeout  36000s;

            send_timeout  36000s;
        }
    	
    	location /seafdav {
            fastcgi_pass    127.0.0.1:8080;
            fastcgi_param   SCRIPT_FILENAME     $document_root$fastcgi_script_name;
            fastcgi_param   PATH_INFO           $fastcgi_script_name;
            fastcgi_param   SERVER_PROTOCOL     $server_protocol;
            fastcgi_param   QUERY_STRING        $query_string;
            fastcgi_param   REQUEST_METHOD      $request_method;
            fastcgi_param   CONTENT_TYPE        $content_type;
            fastcgi_param   CONTENT_LENGTH      $content_length;
            fastcgi_param   SERVER_ADDR         $server_addr;
            fastcgi_param   SERVER_PORT         $server_port;
            fastcgi_param   SERVER_NAME         $server_name;
            client_max_body_size 0;
            proxy_connect_timeout  36000s;
            proxy_read_timeout  36000s;
            proxy_send_timeout  36000s;
            send_timeout  36000s;

            # This option is only available for Nginx >= 1.8.0. See more details below.
            proxy_request_buffering off;
            access_log      /var/log/nginx/seafdav.access.log;
            error_log       /var/log/nginx/seafdav.error.log;
        }
        
    }

    +

    2.测试文件格式正常

    +
    nginx -t

    #nginx: the configuration file /etc/nginx/nginx.conf syntax is ok
    #nginx: configuration file /etc/nginx/nginx.conf test is successful
    +

    重启docker容器

    +

    step4：设置seafile

    +

    修改SERVICE_URL和FILE_SERVER_ROOT

    +

    SERVICE_URL:http://seafile.ninglang.fun

    +

    FILE_SERVER_ROOT:http://seafile.ninglang.fun/seafhttp

    +

    step5：设置seafdav

    +

    设置/conf/seafdav.conf中为

    +
    enabled = true
    port = 8080
    fastcgi = true
    share_name = /seafdav
    +

    在手机端设置

    +

    网络地址:seafile.ninglang.fun/seafdav

    +

    账号密码如实填写

    +]]>     + + Code + +     遗传算法 /2022/02/20/yichuan/