精华内容
下载资源
问答
  • 根号分治是一种思想,一般根据一个数(可以是数组的数,也可以是答案的数)分类,分为大于sqrt(n)sqrt(n)sqrt(n)的部分和小于等于sqrt(n)sqrt(n)sqrt(n)的部分 题目链接: luogu.com.cn/problem/P3396 解题思路: ...

    根号分治

    • 根号分治是一种思想,一般根据一个数(可以是数组的数,也可以是答案的数)分类,分为大于sqrt(n)sqrt(n)的部分和小于等于sqrt(n)sqrt(n)的部分

    • 题目链接: luogu.com.cn/problem/P3396

    • 解题思路: 根号分治的经典题目。我们根据模数分类,模数大于等于sqrt(n)sqrt(n)的部分我们暴力求解,小于等于的部分我们提前预处理出来就好了

    const int N = 2e5 + 5;
    int n , m , a[N];
    int dp[N][405];
    int main ()
    {
        CLOSE;
        cin >> n >> m;
        for (int i = 1 ; i <= n ; i ++)
            cin >> a[i];
        int p = sqrt (n);
        for (int i = 1 ; i <= n ; i ++)
        {
            for (int j = 1 ; j <= p ; j ++)
                dp[j][i%j] += a[i];
        }
        while (m --)
        {
            string op;
            int x, y;
            cin >> op >> x >> y;
            if (op == "A")
            {
                if (x <= p) cout << dp[x][y] << endl;
                else
                {
                    ll ans = 0;
                    for (int j = y ; j <= n ; j += x)
                        ans += a[j];
                    cout << ans << endl;
                }
            }
            else
            {
                for (int j = 1 ; j <= p ; j ++)
                    dp[j][x%j] += (y-a[x]);
                a[x] = y;
            }
        }
    }
    
    • 题目链接: https://codeforces.com/problemset/problem/1446/D2
    • 解题思路: 本题与简单版本的差异在于出现数的种类,那么我们按每个数出现的次数根号分治,那么出现次数大于等于sqrt(n)sqrt(n)的数种类一定是不超过sqrt(n)sqrt(n)那么这一部分我们可以和EesyEesy部分同样处理,接下来是出现次数小于等于sqrt(n)sqrt(n)的这一部分。显然我们也需要根据sqrt(n)sqrt(n)这个复杂度来。所以,我们枚举最终序列中最大出现次数为xxxx属于[1,sqrt(n)][1,sqrt(n)]。接下来可以利用尺取得做法求出每个xx得最大值
    const int N = 2e5 + 5;
    int n , buck[N], a[N];
    int mx, val, cnt;
    int ans = 0;
    unordered_map <int,int> ma;
    void solve1 (int x)
    {
        ma.clear();
        int v = 0;
        ma[0] = 0;
        for (int i = 1 ; i <= n ; i ++)
        {
            if (a[i] == x) v ++;
            if (a[i] == val) v --;
            if (!ma.count(v))
                ma[v] = i;
            else
                ans = max (ans , i - ma[v]);
        }
    }
    void solve2 (int x)
    {
        for (int i = 1 ; i <= n ; i ++) buck[i] = 0;
        int l = 1, type = 0;
        buck[a[l]] ++;
        if (buck[a[l]] == x) type ++;
        for (int i = 2 ; i <= n ; i ++)
        {
            buck[a[i]] ++;
            if (buck[a[i]] == x) type ++;
            else if (buck[a[i]] > x)
            {
                if (buck[a[i]] == x + 1) type --;
                while (buck[a[i]] > x)
                {
                    buck[a[l]] --;
                    if (buck[a[l]] == x) type ++;
                    else if (buck[a[l]] == x - 1) type --;
                    l ++;
                }
            }
            if (type >= 2) ans = max (ans, i - l + 1);
        }
    }
    int main ()
    {
        CLOSE;
        cin >> n;
        mx = 0, val = 0, cnt = 0;
        for (int i = 1 ; i <= n ; i ++) {
            cin >> a[i], buck[a[i]]++;
            if (buck[a[i]] > mx)
                mx = buck[a[i]], val = a[i], cnt = 1;
            else if (buck[a[i]] == mx)
                cnt ++;
        }
        if (cnt > 2)
        {
            cout << n << endl;
            return 0;
        }
        int limit = sqrt (n);
        for (int i = 1 ; i <= n ; i ++)
            if (buck[i] >= limit && i != val)
                solve1 (i);
        for (int i = 1 ; i < limit ; i ++)
            solve2 (i);
        cout << ans << endl;
    }
    
    展开全文
  • 前2500张图片做训练集,后500张图片做测试集,让x分别等于 3 5 6 7 8 10 11 12 13 14 15 ...

     

    取无理数的前3万个有效数字,每10个数字组成一张图片

    前2500张图片做训练集,后500张图片做测试集,让x分别等于

    3

    5

    6

    7

    8

    10

    11

    12

    13

    14

    15

    17

    18

    19

    20

    21

    22

    23

    24

    26

    27

    28

    29

    30

    31

    32

    33

    34

    35

    37

    38

    39

    40

    41

    42

    43

    44

    45

    46

    47

    48

    50

    51

    52

    53

    54

    55

    56

    57

    58

    59

    60

    61

    62

    63

    65

    66

    67

    68

    69

    70

    71

    72

    73

    74

    75

    76

    77

    78

    79

    80

    82

    83

    84

    85

    86

    87

    88

    89

    90

    91

    92

    93

    94

    95

    96

    97

    98

    99

                       

    让网络的收敛标准δ等于0.5到1e-4的16个值,每个值收敛199次取平均值,

    统计当δ=1e-4时的迭代次数和分类准确率与x的关系。

    实验共收敛了89*16*199次

     

    比较迭代次数

    根号x

    迭代次数

    根号x

    迭代次数

    根号x

    迭代次数

    8

    783088.3

    28

    702341.7

    60

    672742

    62

    774492.5

    50

    701950.8

    98

    671972.6

    86

    764687.5

    51

    700513.9

    32

    671520.3

    88

    754498.3

    12

    696393.1

    53

    671064.6

    83

    751454.1

    78

    696308.6

    48

    668988.9

    55

    749043.1

    10

    694794.8

    19

    666679

    52

    746851.5

    15

    694355.3

    65

    666596

    47

    746827.6

    44

    692737

    41

    666001.6

    34

    740813.1

    31

    692346.9

    69

    665235

    84

    740406.4

    61

    692247.9

    54

    662053.5

    11

    740245.7

    46

    692196.6

    18

    660403.3

    29

    735647.9

    90

    691722.7

    6

    659161.1

    67

    732879.5

    33

    690411.6

    22

    659072.1

    59

    732409

    80

    689793.3

    72

    658334.7

    42

    730669.6

    77

    689593.9

    82

    654149.6

    93

    729768.8

    40

    688906.4

    99

    652916.4

    68

    729676.9

    89

    684409.9

    20

    649598.9

    63

    727313.1

    97

    684279.4

    23

    646539.7

    87

    726341.6

    24

    682478.4

    5

    643888.1

    26

    722887.4

    58

    682452.2

    66

    643457.9

    38

    715226.9

    71

    681690.5

    14

    642825.4

    76

    711597.1

    70

    681167.3

    45

    629977.4

    56

    708782.5

    96

    681095.3

    75

    629553.8

    17

    708562.8

    35

    679045.2

    3

    625240.1

    74

    706798.2

    27

    678591.1

    30

    625240.1

    13

    705637.6

    85

    677746.7

    39

    622623.4

    7

    705298.8

    73

    676184.8

    91

    621037

    43

    704949.2

    57

    675862

    92

    619325.5

    21

    704103.6

    95

    674251.1

    94

    614488.7

    37

    702753.7

    79

    673434.8

       

    迭代次数最大的是根号8,迭代次数最小的是根号94.

    假设1:完全相同的两个对象无法被分成两类,与之对应的分类迭代次数为无穷大,分类准确率是50%,50%。相等收敛标准下迭代次数越大表明二者差异越小。

    按照假设1,这个结果表明根号2的结构与根号94差异最大,而与根号8差异最小。

     

    再比较分类准确率

    根号x

    分类准确率

    根号x

    分类准确率

    根号x

    分类准确率

    99

    0.5161005

    35

    0.50381407

    15

    0.49998492

    74

    0.51311558

    14

    0.50380905

    32

    0.49952764

    79

    0.51069849

    37

    0.50368342

    58

    0.49948241

    69

    0.51055779

    31

    0.50361809

    43

    0.49939698

    34

    0.51042714

    91

    0.50271859

    88

    0.49869849

    23

    0.51020101

    87

    0.50252261

    77

    0.49860804

    96

    0.50925126

    20

    0.50240201

    24

    0.49809045

    5

    0.50867337

    19

    0.50236181

    75

    0.49795477

    66

    0.50859799

    40

    0.50234673

    46

    0.49762312

    44

    0.50835176

    94

    0.50205025

    29

    0.49750754

    3

    0.50807035

    12

    0.50203518

    93

    0.49747236

    30

    0.50807035

    82

    0.50203015

    63

    0.49735678

    17

    0.50775377

    89

    0.50193467

    55

    0.49731156

    28

    0.50769347

    92

    0.50179899

    78

    0.4970804

    21

    0.50766834

    73

    0.50162312

    33

    0.49652261

    52

    0.50729648

    50

    0.50157286

    56

    0.49651759

    85

    0.50729648

    76

    0.50153266

    68

    0.49651759

    13

    0.50723618

    26

    0.50148241

    61

    0.49647739

    42

    0.50712563

    53

    0.50142211

    83

    0.49605025

    72

    0.50709548

    84

    0.50133166

    8

    0.49590452

    39

    0.50667839

    6

    0.50131156

    98

    0.49525628

    27

    0.50647739

    65

    0.50085427

    97

    0.49509548

    60

    0.50603015

    62

    0.50074874

    67

    0.49441206

    7

    0.50596985

    54

    0.50054271

    71

    0.49424623

    90

    0.5058191

    48

    0.50050754

    70

    0.49405025

    10

    0.50578392

    45

    0.50046734

    47

    0.49370352

    57

    0.50446734

    95

    0.50039196

    11

    0.49312563

    59

    0.50443216

    41

    0.50027136

    51

    0.49240201

    38

    0.50405025

    22

    0.50018593

    18

    0.48945729

    86

    0.5039397

    80

    0.50008543

       

    有60个数的分类准确率的平均值是大于50%的,其中最大的是根号99,可以达到51.61%。

     

     

    https://www.wolframalpha.com/

    N[sqr(2),30000]

     

    比如根号2和根号3的数据是

    g2g3

                       

    训练集

    0-2500

                     

    测试集

    2500-3000

                     

    f2[0]

    f2[1]

    迭代次数n

    平均准确率p-ave

    δ

    耗时ms/次

    耗时ms/199次

    耗时 min/199

    最大值p-max

    迭代次数标准差

    pave标准差

    0.500338192

    0.499239469

    20.55778894

    0.500080402

    0.5

    5.256281407

    1052

    0.017533333

    0.524

    25.22970705

    0.003709768

    0.467823775

    0.5322995

    11919.66834

    0.516839196

    0.4

    133.9045226

    26653

    0.444216667

    0.531

    969.2051142

    0.007147707

    0.555233687

    0.444791463

    57628.05528

    0.519824121

    0.3

    628.3266332

    125043

    2.08405

    0.536

    23085.578

    0.004646739

    0.616973437

    0.382998604

    135998.9497

    0.512130653

    0.2

    1476.110553

    293751

    4.89585

    0.539

    19865.73736

    0.009454095

    0.733029551

    0.266970767

    191893.0201

    0.513376884

    0.1

    2068.492462

    411637

    6.860616667

    0.554

    25796.91008

    0.01233183

    0.694724672

    0.305275328

    303482.5276

    0.507361809

    0.01

    3274.658291

    651664

    10.86106667

    0.556

    21025.07752

    0.014651041

    0.642949758

    0.357050292

    418999.3568

    0.506165829

    0.001

    4491.703518

    893852

    14.89753333

    0.545

    47223.97265

    0.015214963

    0.637957293

    0.362042703

    420436.4372

    0.507

    9.00E-04

    4506.653266

    896830

    14.94716667

    0.543

    42325.38175

    0.014135738

    0.562718115

    0.437281893

    431819.0553

    0.50618593

    8.00E-04

    4635.075377

    922391

    15.37318333

    0.557

    50420.4394

    0.01460779

    0.597865141

    0.402134839

    440818.8392

    0.502422111

    7.00E-04

    4669.361809

    929210

    15.48683333

    0.551

    55378.81957

    0.016427478

    0.562741749

    0.437258266

    458893.4372

    0.505748744

    6.00E-04

    4868.668342

    968868

    16.1478

    0.554

    61587.45673

    0.016143427

    0.592875786

    0.407124209

    462545.7789

    0.506160804

    5.00E-04

    4901.522613

    975407

    16.25678333

    0.54

    55633.63555

    0.014304452

    0.612977949

    0.387022063

    490165.3065

    0.50620603

    4.00E-04

    5200.180905

    1034847

    17.24745

    0.546

    75881.90078

    0.013377877

    0.567800493

    0.432199477

    515554.4271

    0.505447236

    3.00E-04

    5476.834171

    1089896

    18.16493333

    0.556

    77536.28047

    0.015290684

    0.607998131

    0.392001886

    576056.5377

    0.505371859

    2.00E-04

    6097.01005

    1213314

    20.2219

    0.54

    95671.37734

    0.014181608

    0.638164184

    0.361835814

    625240.1055

    0.508070352

    1.00E-04

    6616.929648

    1316774

    21.94623333

    0.549

    115278.666

    0.015353296

     

    展开全文
  • 以开64开6次根号为例 先按6=>再按shift=>再按开方=>输入你要输入的开方的数字=>按等于号 1: 2: 3: 4:输入64 5:按等于号。

    以开64开6次根号为例
    先按6=>再按shift=>再按开方=>输入你要开方的数字=>按等于号

    1:
    在这里插入图片描述
    2:
    在这里插入图片描述
    3:
    在这里插入图片描述
    4:输入64
    5:按等于号。

    展开全文
  • Description 给定一个n个点的树,树上每个点有一个字符,再给一个长度为m的串。 两点的价值为:两点连接形成的字符串再m串中出现的...对于一个点分治块,假如它的大小小于等于n\sqrt nn​,那么直接对于每一个点暴力...

    Description
    给定一个n个点的树,树上每个点有一个字符,再给一个长度为m的串。
    两点的价值为:两点连接形成的字符串再m串中出现的次数。
    询问两两点价值的和。


    Sample Input
    3 5
    1 2
    1 3
    aab
    abaab


    Sample Output
    15


    首先考虑点分治。
    然后再考虑根号分治
    对于一个点分治块,假如它的大小小于等于n\sqrt n,那么直接对于每一个点暴力去做它可以形成的所有串,可以用自动机在dfs中O(1)O(1)维护一个串出现的次数。
    这一部分时间复杂度不超过O(nn)O(n\sqrt n)
    对于大于等于n\sqrt n的块,我们只用考虑经过分治中心的点即可。
    对于一条路径(x,y),设分治中心为g,则我们考虑对于一个m串中的位置p的贡献。我们算出(x,g)经过了p的次数,(g,y)经过了p的次数,相乘即可。
    先考虑(x,g),我们可以建出一个parent树,从g往下走,就相当于每次都在前面插个字符,那就相当于直接在parent树上走,边走边打标记,最后再跑一边parent树累加标记即可。
    对于(g,y)就相当于在后缀树上做。
    因为所有这样的块不超过n\sqrt n个,所以这样的时间复杂度为O(nn)O(n\sqrt n)


    #include <cmath>
    #include <ctime>
    #include <cstdio>
    #include <cstring>
    #include <cstdlib>
    #include <algorithm>
    
    using namespace std;
    typedef long long LL;
    const int N = 100010;
    int _max(int x, int y) {return x > y ? x : y;}
    int _min(int x, int y) {return x < y ? x : y;}
    int read() {
    	int s = 0, f = 1; char ch = getchar();
    	while(ch < '0' || ch > '9') {if(ch == '-') f = -1; ch = getchar();}
    	while(ch >= '0' && ch <= '9') s = s * 10 + ch - '0', ch = getchar();
    	return s * f;
    }
    
    struct edge {
    	int x, y, next;
    } e[2 * N]; int len, n, m, last[N];
    char yy[N], tt[N];
    bool v[N];
    struct SAM {
    	int cnt, lst, fa[N * 2], len[N * 2], right[N * 2], ch[N * 2][26], son[N * 2][26];
    	int s[N], size[N], id[N * 2], ss[N], tag[N];
    	void ins(int c, int i) {
    		int np = ++cnt, p = lst; ss[i] = c;
    		len[np] = len[p] + 1; right[np] = i; size[np] = 1;
    		while(p && !ch[p][c]) ch[p][c] = np, p = fa[p];
    		if(!p) fa[np] = 1;
    		else {
    			int q = ch[p][c];
    			if(len[p] + 1 == len[q]) fa[np] = q;
    			else {
    				int nq = ++cnt;
    				fa[nq] = fa[q]; len[nq] = len[p] + 1;
    				memcpy(ch[nq], ch[q], sizeof(ch[nq]));
    				fa[np] = fa[q] = nq;
    				while(p && ch[p][c] == q) ch[p][c] = nq, p = fa[p];
    			}
    		} lst = np;
    	}
    	void bt() {
    		for(int i = 1; i <= cnt; i++) ++s[len[i]];
    		for(int i = 1; i <= m; i++) s[i] += s[i - 1];
    		for(int i = cnt; i >= 1; i--) id[s[len[i]]--] = i;
    		for(int i = cnt; i >= 1; i--) {
    			int x = id[i], F = fa[x];
    			size[F] += size[x];
    			right[F] = _max(right[F], right[x]);
    			son[F][ss[right[x] - len[F]]] = x;
    		}
    	}
    	void work(int x, int fa, int now, int ll) {
    		if(ll == len[now]) now = son[now][tt[x]];
    		else if(ss[right[now] - ll] != tt[x]) now = 0;
    		if(!now) return ; ++tag[now];
    		for(int k = last[x]; k; k = e[k].next) {
    			int y = e[k].y;
    			if(y != fa && !v[y]) work(y, x, now, ll + 1);
    		}
    	}
    	void push() {
    		for(int i = 1; i <= cnt; i++) tag[id[i]] += tag[fa[id[i]]];
    	}
    } sam1, sam2;
    int sum, block, tot[N], f[N];
    int tp, now, sta[N];
    int id1[N], id2[N];
    LL ans;
    
    void ins(int x, int y) {
    	e[++len].x = x, e[len].y = y;
    	e[len].next = last[x], last[x] = len;
    }
    
    int getrt(int x, int fa) {
    	int p = 0;
    	tot[x] = 1; f[x] = 0;
    	for(int k = last[x]; k; k = e[k].next) {
    		int y = e[k].y;
    		if(y != fa && !v[y]) {
    			int hh = getrt(y, x);
    			if(f[hh] < f[p]) p = hh;
    			tot[x] += tot[y];
    			f[x] = _max(f[x], tot[y]);
    		}
    	} f[x] = _max(f[x], sum - tot[x]);
    	if(f[x] < f[p]) p = x;
    	return p;
    }
    
    void get(int x, int fa) {
    	sta[++tp] = x;
    	for(int k = last[x]; k; k = e[k].next) {
    		int y = e[k].y;
    		if(y != fa && !v[y]) get(y, x);
    	}
    }
    
    void getsum(int x, int fa) {
    	if(!now) return ;
    	int hh = now; ans += sam1.size[now];
    	for(int k = last[x]; k; k = e[k].next) {
    		int y = e[k].y;
    		if(y != fa && !v[y]) {
    			now = sam1.ch[now][tt[y]], getsum(y, x);
    			now = hh;
    		}
    	}
    }
    
    void calc(int x, int fa, int o) {
    	for(int i = 1; i <= sam1.cnt; i++) sam1.tag[i] = 0;
    	for(int i = 1; i <= sam2.cnt; i++) sam2.tag[i] = 0;
    	if(o == 1) sam1.work(x, 0, 1, 0), sam2.work(x, 0, 1, 0);
    	else sam1.work(x, 0, sam1.son[1][tt[fa]], 1), sam2.work(x, 0, sam2.son[1][tt[fa]], 1);
    	sam1.push(), sam2.push();
    	for(int i = 1; i <= m; i++) ans += (LL)o * sam1.tag[id1[i]] * sam2.tag[id2[m - i + 1]];
    }
    
    void solve(int x) {
    	if(sum <= block) {
    		tp = 0; get(x, 0);
    		for(int i = 1; i <= tp; i++) now = sam1.ch[1][tt[sta[i]]], getsum(sta[i], 0);
    		return ;
    	} v[x] = 1;
    	calc(x, 0, 1);
    	for(int k = last[x]; k; k = e[k].next) {
    		int y = e[k].y;
    		if(!v[y]) {
    			calc(y, x, -1);
    			sum = tot[y], solve(getrt(y, 0));
    		}
    	}
    }
    
    int main() {
    	n = read(), m = read();
    	for(int i = 1; i < n; i++) {
    		int x = read(), y = read();
    		ins(x, y), ins(y, x);
    	} scanf("%s", tt + 1);
    	scanf("%s", yy + 1);
    	sam1.cnt = sam2.cnt = sam1.lst = sam2.lst = 1;
    	for(int i = 1; i <= m; i++) yy[i] -= 'a', sam1.ss[i] == yy[i], sam1.ins(yy[i], i), id1[i] = sam1.lst;
    	reverse(yy + 1, yy + m + 1);
    	for(int i = 1; i <= m; i++) sam2.ss[i] == yy[i], sam2.ins(yy[i], i), id2[i] = sam2.lst;
    	sam1.bt(), sam2.bt();
    	f[0] = 999999999; block = sqrt(n);
    	for(int i = 1; i <= n; i++) tt[i] -= 'a';
    	sum = n, solve(getrt(1, 0));
    	printf("%lld\n", ans);
    	return 0;
    }
    
    
    展开全文
  • 分析: 把指数的2带入 原式等于 $ [(5+2\sqrt{6})^n] $ 有一个重要的结论是n次运算后其结果最终形式也是$ a_n+b_n\sqrt{6} $ 的形式 记最终的解$ F(n) = a_n+b_n\sqrt{6} $ $ F(n-1) = a_{n-1}+b_{n-1}\sqrt{6} $ $.....
  • 例如:3 只能被1和3整除,5,7,9 这些都是。4,6这些都不是质数(注意2是质数)。 2,基本思想: (1)首先2肯定是一个质数,先打印出来 (2)使用循环,从3开始到不大于n。优化要点:不要都遍历到,把偶数的给排除...
  • 求取根号5,并且满足精度小于10的负6次方。 2 方法 记 f(x)=x2−5f(x) = x^2-5f(x)=x2−5; 求取方程 等于0 的根。 方法一 二分法 不断维护left,rightleft, rightleft,right ,使得两者相乘小于0。 方法二:迭代法 ...
  • 判断n是否素数的另一个更高效的方法是:检验小于等于根号n的素数是否有一个能被n整除。如果都不能,则n就是素数。使用这个方法该些程序清单5-15以显示前50个素数。需要使用一个数组存储这些素数,之后使用这些素数来...
  • 题意很简单就不说了。 因为n % x = n - n / x * x 所以答案就等于 n * m - (n/1*1 + n/...在根号n复杂度枚举x,注意一点当m>n时,后面一段加起来就等于0,就不用再枚举了。 中间一段x1 ~ x2 的n/x可能相等,...
  • 虚数现在才知道,个人理解为,假设1*(-1)=-1,可以写为1√(-1)√(-1)=-1,那么设根号负一等于i,根号负一平方根=-1,根号负一0次方等于1. 其实这些可以用坐标轴来表示,横着表示实数,竖轴表示虚数,那么复数就...
  • 因为,不管n等于几,得数总可以表示为an+bn*根号6(a1=5,b1=2),这样就可以构造矩阵来算。算出来an和bn以后,计算(an+bn*根号6)mod1024,结果发现连样例都过不了,这是因为根号6不是整数,我们平时习以为常的等式失效...
  • 比如n=100的话,i=4时n/i等于25,i=5时n/i等于20,于是在大于20到小于等于25内的5个数字j都有n/j等于4,然后ans+=4*5 所以我们可以在小于等于根号n的范围内枚举i,ans+=n/i,然后ans+=(n/(i)-n/(...
  • 题解:开根号向下正得到1的最大的数为3.9999999……(约等于2^2),开根号向下取整得到4(2^2)的最大的数为15.9999999……(约等于2^4),…………可以得到能在五次之内开根取整得到1的最大值为2^32. 先判断边界是否...
  • hdu 5752 Sqrt Bo

    2016-07-27 09:23:00
    首先要大致估算一下,多少位的数开5根号等于1,引用qsc: 1->3->15->255->65535->4294967295 所以最大是10位,所以开个long long换字符串,之后每次都根号,最后输出就好了 代码: #include <...
  • 【matlab】norm的用方法

    2020-09-09 17:39:15
    【matlab】norm的用方法 从上面可以得到,对一个向量P=[5,0,1],norm§就等于各项的平方和再开根号
  • python 简易计算器

    2017-11-26 23:22:00
    import tkinter import tkinter.messagebox import math ''' 波波版计算器可实现的功能 ...5.可以连续开根号 解决的bug 5.连续错按运算符号之后按最后一个运算符运算 6.连续按等于号可以连乘3×3=9 再按...
  • 斐波那契数列经典实例

    千次阅读 2017-03-28 22:46:49
    斐波那契数列指的是这样一个数列...它的通项公式为:(1/√5)*{[(1+√5)/2]^n - [(1-√5)/2]^n}【√5表示根号5】 斐波那契数列按照其递推公式可简单写出递归算法:int fib1(int n) { if(n == 1 || n == 2) return 1;
  • 向量

    2020-10-11 23:00:43
    比如 向量a(1,2,3) 12 +22+32=14 然后开根号 等于 3.74 那么 向量a的长度为:3.74 可用 |a| 表示向量的长度 计算向量单位化: 用向量/向量长度 2个单位向量可以用来表示两个方向,这两个方向可以进行比较(同...
  • 给定一个非负整数 c ,你要判断是否存在两个整数 a 和 b,使得 a 的平方加 b 的平方等于 c 。 复制代码 示例: 输入: 5 输出: True 解释: 1 * 1 + 2 * 2 = 5 输入: 3 输出: False 复制代码 思考: 这题因为 a * a...
  • 素数

    2012-03-21 14:29:00
    * 如果n是素数,那么n必须有一个大于1且小于等于根号n的因子 * 所以只需要检测2,3,4,5,...根号n是够能整除n,如果不能,n就是素数 * */ public class PrimNumbers { public static void main(String[] ...
  • python学习记录(6)

    2020-12-01 10:44:51
    python学习记录(6) Python 的 floor 除法现在使用 “//” 实现...1/根号5 如何简单判断一个数是奇数还是偶数? if num%2==1 奇数 else 偶数 请用最快速度说出答案:not 1 or 0 and 1 or 3 and 4 or 5 and 6 or
  • 斐波那契数列指的是这样一个数列:1、1、2、3、5、8、13、21、……  这个数列从第三项开始...)(√5表示根号5)  有趣的是:这样一个完全是自然数的数列,通项公式居然是用无理数来表达的。    用数学公式表示
  • 1 // 判断相同区间(lazy) 多校8 HDU 5828 Rikka with Sequence 2 // 题意:三种操作,1增加... 4 // 注意开根号的话,遇到极差等于1的,开根号以后有可能还是差1.如 5 // 2 3 2 3。。。 6 // 8 9 8 9。。。 ...
  • 题目描述 求正整数N(N>1)的质因数的个数。 相同的质因数需要重复...思路:对一个正整数n来说,如果它存在[ 2 , n ]范围内的质因子,要么这些质因子全部小于等于根号n,要么只存一个大于根号n的质因子,而其余因子

空空如也

空空如也

1 2 3 4
收藏数 67
精华内容 26
关键字:

根号5等于