精华内容
下载资源
问答
  • 多维分值计算实例

    2019-06-06 15:10:51
    查询红名单报警共20次 警员A触发3次top分值为100,100,100 小时查询量异常共3000次 警员A触发 10次 top分值为 100,100,100,80,60 高频查询异常共1000次 警员A触发 1次 top分值为80 夜间查询共10次 警员A触发0次 ...

    查询红名单报警共20次  警员A触发3次  top分值为 100,100,100

    小时查询量异常共3000次   警员A触发 10次  top分值为 100,100,100,80,60

    高频查询异常共1000次     警员A触发 1次  top分值为80

    夜间查询共10次    警员A触发0次

    若直接划分100分总分 则 比值为 20:3000:1000:200 差距很大 红名单异常会被稀释

    所以执行第一步

    a) 利用lnX函数,将离散率较大的报警频率映射至较小的离散区间

    为计算方便计算lnX时取整

    则ln20 =3  ln3000=8   ln1000=7  ln200=2  总和为20

    执行第二部

    b) 将映射后的数值正比例切分分值上限(100分),并根据比例得出每种报警的极限分值;

    所以得出 红名单报警分值上限是(3/20)X100 = 15分  占总分值15%

    以此类推  15% ,40%,35%,10%

    得出分值占比后执行第三步

    c) 取单人的报警ID及分值top5报警,加权(1/2 N次方),求和,得出单种类报警异常分值

    红名单得分(100*1/2+100*1/4+100*1/8) = 87.5分

    小时量异常得分 (100*1/2+100*1/4+100*1/8+80*1/16+60*1/16)=96.25分 PS:因为取5次所以第五次是1/16 不是1/32  

    高频得分 (80*1/2) = 40分

    夜间得分 0分

    d) 将c得出的分值映射至b得出的极限分值

    乘以分值占比  87.5*15% =13.125分 

    乘以得分占比 96.25*40% = 38.5分

    乘以得分占比 40*35% =14分

    e) 循环d,累加后求出最终异常分值

    最后分值 13.125+38.5+14 = 65.625分

    因为有些报警并不是报的次多就比较重要,报少的反而重视,例如红名单报警,所以新增反比例系数

    反比例系数计算方式 将第一步a的比例系统做反比调整计算方式如下:

    报警次数总和为20+3000+1000+10 = 4030次

    红名单系数为ln(4030/20)约为ln(200)

    小时量异常系数ln(4030/3000) 约为 ln(1.3)

    以此方式重复上述过程,报警次数少的比例将远远增大,逆向分值大就代表具有个性的报警较多。将正向分值与逆向分值 取较大值 则为 最终的报警分值

    展开全文
  • 基准时间限制:1.5秒 空间限制:131072KB 分值:80 区间内所有元素排序后,任意相邻两个元素值差为1的区间称为“连续区间” 如:3,1,2是连续区间,但3,1,4不是连续区间 给出一个1~n的排列,求出有...
    1810 连续区间
    基准时间限制:1.5 秒 空间限制:131072 KB 分值: 80
     
     
    区间内所有元素排序后,任意相邻两个元素值差为1的区间称为“连续区间”
    如:3,1,2是连续区间,但3,1,4不是连续区间
    给出一个1~n的排列,求出有多少个连续区间
    Input
    一个数n(n<=1,000,000)
    第二行n个数,表示一个1~n的排列
    Output
    一个数,表示有多少个连续区间
    Input示例
    5
    2 1 5 3 4
    Output示例
    9
    样例解释:
    区间[1,1][2,2][3,3][4,4][5,5][1,2][4,5][3,4][1,5]为连续区间//[l,r]表示从第l个数到第r个数构成的区间

     
    题解:
      分治计数
      先将序列划分为左右两边,只考虑左端点在左边部分,右端点在右边部分的答案
      也就是左边部分对右边部分答案的贡献
      可知
           Max{max(i),max(j)} - Min{min(i),min(j)} = j - i;
      共有4中互不影响的情况,其实这里分类讨论下就可以O(1)求出
    #include <bits/stdc++.h>
    inline long long read(){long long x=0,f=1;char ch=getchar();while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}return x*f;}
    using namespace std;
    #define ls i<<1
    #define rs ls | 1
    #define mid ((ll+rr)>>1)
    #define MP make_pair
    typedef long long LL;
    typedef unsigned long long ULL;
    const long long INF = 1e18+1LL;
    const double pi = acos(-1.0);
    const int N = 1e6 + 10, M = 502, inf = 1e9;
    
    LL ans,mx[N],mx1[N],mn[N],mn1[N],vis[N * 3];
    int a[N],n;
    
    void solve(int ll,int rr) {
        if(ll == rr) return ;
        int last1 = -1,last2 = inf;
        for(int i = mid; i >= ll; --i)
            mx[i] = max(last1,a[i]),last1 = mx[i],
            mn[i] = min(last2,a[i]),last2 = mn[i];
        last1 = -1,last2 = inf;
        for(int i = mid+1; i <= rr; ++i)
            mx1[i] = max(last1,a[i]),last1 = mx1[i],
            mn1[i] = min(last2,a[i]),last2 = mn1[i];
    
        for(int i = ll; i <= mid; ++i) {
            int tmp = i + mx[i] - mn[i];
            if(tmp > mid && tmp <= rr
               && mx[i] > mx1[tmp] && mn[i] < mn1[tmp]) ans+=1;
        }
    
    
        for(int i = mid+1; i <= rr; ++i) {
            int tmp = i - mx1[i] + mn1[i];
            if(tmp >= ll && tmp <= mid
               && mx1[i] > mx[tmp] && mn1[i] < mn[tmp]) ans+=1;
        }
        int l = mid+1,r = mid;
        for(int i = mid; i >= ll; --i) {
           while(r < rr && mx[i] > mx1[r+1]) ++r, vis[r+mn1[r]+n]++;
           while(l <= r && mn[i] < mn1[l]) vis[l+mn1[l]+n]--,++l;
           ans += vis[i+mx[i]+n];
        }
        while(l <= r) vis[l+mn1[l]+n]--,l++;
    
        l = mid, r = mid+1;
        for(int i = mid+1; i <= rr; ++i) {
            while(r > ll && mx1[i] > mx[r-1]) r--,vis[r-mn[r]+n]++;
            while(l >= r && mn[l] > mn1[i]) vis[l-mn[l]+n]--,l--;
            ans += vis[i-mx1[i]+n];
        }
        while(l >= r) vis[l-mn[l]+n]--,l--;
        solve(ll,mid),solve(mid+1,rr);
    }
    int main() {
        scanf("%d",&n);
        for(int i = 1; i <= n; ++i) a[i] = read();
        solve(1,n);
        printf("%lld\n",ans+n);
        return 0;
    }

     

     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     
     

    转载于:https://www.cnblogs.com/zxhl/p/7571066.html

    展开全文
  • 区间DP

    2021-04-27 20:09:41
    简单介绍:区间DP就是在区间上进行动态规划,求解一段区间上的最优解, 通过合并小区间的最优解进而得出大区间上的最优解。 定义状态时,定义的是一段区间 本文章,主要通过几道经典例题的分析来试着阐述区间dp。...

    简单介绍:区间DP就是在区间上进行动态规划,求解一段区间上的最优解, 通过合并小区间的最优解进而得出大区间上的最优解。
    定义状态时,定义的是一段区间

    本文章,主要通过几道经典例题的分析来试着阐述区间dp。初次接触,可能很是浅显,欢迎指正和建议@^@

    石子合并

    题目链接
    简单概述:
    在这里插入图片描述
    分析:

    1. 题目特点:我们每次只能合并相邻两堆

    2. 最后合并的两堆,一堆是左边连续的一部分,另一堆是右边连续的一部分。

    3. 状态表示:
      【(1)化零为正所有不同合并方式一定是有限的,(2)枚举必超时。】
      集合:所有将[i,j]合并成一堆的方案的集合f[i,j] 我们要求的是最小值。

    4. 状态计算:f[i, j]
      想要试图找到状态转移的方程时,我们可以根据最后一步来确定划分依据。比如左边最后一堆是谁。在这里,左边最后一堆我们可以是i; i + 1; …j - 1;我们把这些情况都求出来,取最小值,即为[i, j]区间上所求最小值。我们看这个区间的第k类取法:这时的两大区间[i, k], [k + 1, j]两区间毫无影响。左边取最小,右边取最小。S[n]意为从1-n的所有元素的和。
      f[i][j] = f[i][k] + f[k + 1, j] + S[j]- S[i - 1]

    5. 时间复杂度: n ^3;

    关于代码解释

    1. 我们写区间DP时,一般先写区间长度,再枚举区间左端点,区间右端点
    2. f[1][N]带入定义,意为:将1-n堆的石子合并成一堆花费的最小代价。即为所求。
    #include <iostream>
    #include <algorithm>
    using namespace std;
    const int N = 310;
    int S[N]; //前缀和
    int f[N][N]; 
    int main(void){
    	int n;
    	cin >> n;
    	for(int i = 1; i <= n; i ++) cin >> S[i], S[i] += S[i-1];
    	for(int len = 2; len <= n; len ++){
    		for(int i = 1; i +  len - 1 <= n; i ++){ 
    		/*关于这里循环条件的一点解释:i+len-1正好为右端点,小于等于n*/
    			int j = i + len - 1;
    			f[i][j] = 1e9 + 10;
    			for(int k = i; k <= j - 1; k ++){
    				f[i][j] = min(f[i][j], f[i][k] + f[k + 1][j] + S[j] - S[i - 1]);
    			}
    		}
    	}
    	cout << f[1][n];
    	return 0;
    }
    

    环形石子合并

    题目链接

    在这里插入图片描述
    分析:

    1. 环形区间可以变成一条链
      (1)朴素版本,非常朴素,以致会超时。
      我们把该题作为上道基本石子合并的一个拓展。n堆石子可以看成组成环的n个点,当我们将两堆合并时,相当于在两点之间画一条线。当把n堆合并完成后,一定会有一个缺口,(此时,这两点间没有连线,而n堆石子已然合并成一堆了),我们可以由此受到启发,不妨枚举缺口位置,转化成上题石子合并问题。
      时间复杂度:n ^ 4, emmmnn, 会超时
      (2)优化:本质上是要求n个长度为n的链上的石子合并问题。先将整个环形展开,复制一遍,即再来相同的八个点,变成长度为2*n的链。当在1和8间断开,得到的如图中上面的那条链表示;当1和2断开,即下面那条红色链。

    在这里插入图片描述
    我们对长度为2*n的链做一遍上面那道石子合并的处理,我们处理出来所有在这段长度上的f[i][j] ,那么在所有长度为n的区间里取一个最小值即可。时间复杂度:(2*n) ^ 3

    代码:
    注意:我们需要给f,g数组初始化最大最小,且在区间长度为1时,更新为1

    #include <iostream>
    #include <algorithm>
    #include <cstring>
    using namespace std;
    const int N = 400;
    int S[N], w[N]; //前缀和
    int f[N][N], g[N][N]; 
    int main(void){
    	int n;
    	cin >> n;
    	for(int i = 1; i <= n; i ++){
    		cin >> w[i];
    		w[i + n] = w[i];
    	}
    	for(int i = 1; i <= 2 * n; i ++){
    		S[i] = S[i - 1] + w[i];
    	}
    	memset(f, 0x3f, sizeof(f));//记录最小值 
    	memset(g, 0, sizeof(g));//记录最大值 
    	for(int len = 1; len <= n; len ++){
    		for(int l = 1; l + len - 1 <= 2 * n; l ++){
    			int r = l + len - 1;
    			if(len == 1) g[l][r] = f[l][r] = 0;
    			for(int k = l; k <= r - 1; k ++){
    				f[l][r] = min(f[l][r], f[l][k] + f[k + 1][r] + S[r] - S[l-1]);
    				g[l][r] = max(g[l][r], g[l][k] + g[k + 1][r] + S[r] - S[l-1]);
    			}
    		}
    	}
    	int maxn = 0, minn = 1e9 + 10;
    	for(int i = 1; i <= n; i ++){
    		maxn = max(maxn, g[i][i+n-1]);
    		minn = min(minn, f[i][i+n-1]);
    	}
    	cout << minn << endl;
    	cout << maxn << endl;
    	return 0;
    }
    

    能量项链

    题目链接

    在这里插入图片描述
    输入样例:
    4
    2 3 5 10
    输出:710.

    分析:

    1. f[L][R]表示将[L,R]合并成一个珠子的方式。取max

    (1)我们不妨先把它想成一条链(具体怎么样一条链,且听我娓娓道来。后文再说@^@)
    以样例为例,我们不妨把它看成 2 3 5 10 2
    共5个数,每次合并相邻的俩。那么f[L,R]便有左分界点:L+1, L+2…R-2, R-1, 对应的关系:以左分界点为k的说:f[l][r] = f[l][k] + f[k][r] + w[l]*w[k]*w[r]那样例对应的所求为f[1][5]
    (2)与上题类似,我们把它展成长度为2*n的链,求区间为n+1长度的最大值即可。
    为何是n+1?以样例为例我们不妨给每个珠子的两个编号(1, 2), (2, 3), (3, 4), (4, 5)(注意输入的2、3、5、10只是与其价值有关),我们模拟从左到右依次合并的场景:
    第一步:(1,3)区间长度3-1+1=3;第二步:(1,4)区间长度:4-1+1=3; 第三步:(1, 5)5-1+1=5.(区间包含左右端点)
    那这也就解释了为何区间长度我们从3开始枚举。

    代码

    #include <bits/stdc++.h>
    using namespace std;
    const int N = 210;
    int w[N];
    int f[N][N];
    int main(void){
        int n;
        cin >> n;
        for(int i = 1; i <= n; i ++){
            cin >> w[i];
            w[i + n] = w[i];
        }
        for(int len = 3; len <= n + 1; len ++){
            for(int l = 1; l + len - 1 <= 2 * n; l ++){
                int r = l + len - 1;
                for(int k = l + 1; k <= r - 1; k ++){
                    f[l][r] = max(f[l][r], f[l][k] + f[k][r] + w[l] * w[k] * w[r]);
                }
            }
        }
        int maxn = 0;
        for(int l = 1; l <= n; l ++){
            maxn = max(maxn, f[l][l+n]);
        }
        cout << maxn << endl;
        return 0;
    }
    

    凸多边形的划分

    和高精度的一个结合版

    题目链接

    题目描述:
    在这里插入图片描述

    分析:

    1. f[L][R] = K含义: 所有将(L, L+1), (L+1, L + 2), …(R-1, R),(R, L)这个多边形划分成三角形的方案中,最小值为K。

    在这里插入图片描述

    1. 状态计算:f[L][K] = min(f[L][K] + f[K][R] + w[L] * w[K] * w[R])
    2. 与上道题相差不大,但是结合了高精度。

    代码一(数组做法):

    #include <iostream>
    #include <cstring>
    #include <algorithm>
    using namespace std;
    const int N = 55, M = 35;
    typedef long long LL;
    int n;
    int w[N];
    LL f[N][N][M];
    //数据在数组中的存储为逆序存储,例如123, 在数组中为321 
    void add(LL a[], LL b[]){
    	LL c[M];
    	memset(c, 0, sizeof c);
    	for(int i = 0, t = 0; i < M; i ++){
    		t += a[i] + b[i];
    		c[i] = t % 10;
    		t /= 10;
    	}
    	memcpy(a, c, sizeof c);
    }
    void mul(LL a[], LL b){
    	LL c[M];
    	memset(c, 0, sizeof c);
    	LL t = 0;
    	for(int i = 0; i < M; i ++){
    		t += a[i] * b; 
    		c[i] = t % 10;
    		t /= 10;
    	}
    	memcpy(a, c, sizeof c);
    }
    int cmp(LL a[], LL b[]){
    	for(int i = M - 1; i >= 0; i --){
    		if(a[i] > b[i]) return 1;
    		else if(a[i] < b[i]) return -1;
    	}
    	return 0;
    }
    void print(LL a[]){
    	int k = M - 1;
    	while(k && !a[k]) k --;
    	while(k >= 0) cout << a[k --];
    	cout << endl;
    }
    int main(void){
    	cin >> n;
    	for(int i = 1; i <= n; i ++) cin >> w[i];
    	LL temp[M];
    	for(int len = 3; len <= n; len ++){
    		for(int i = 1; i + len - 1 <= n; i ++){
    			int l = i, r = i + len - 1;
    			f[l][r][M - 1] = 1; //开始初始化为大于最大值的一个值,因为我们要求最小值。 
    			
    			for(int k = l + 1; k < r; k ++){
    				memset(temp, 0, sizeof temp);
    				temp[0] = w[l];
    				mul(temp, w[k]), mul(temp, w[r]);
    				add(temp, f[l][k]), add(temp, f[k][r]);
    				if(cmp(f[l][r], temp) > 0){
    					memcpy(f[l][r], temp, sizeof temp);
    				} 
    			}
    		}
    	}
    	print(f[1][n]);
    	return 0;
    }
    

    代码二:(完全是手写的高精度模板)
    高精度模板链接 戳我

    #include <iostream>
    #include <cstring>
    #include <vector>
    #include <algorithm>
    using namespace std;
    const int N = 55, M = 35;
    typedef long long LL;
    int n;
    int w[N];
    vector<int>f[N][N];
    vector<int> add(vector<int> &a, vector<int> &b){
    	vector<int>c;
    	int t = 0;
    	for(int i = 0; i < a.size() || i < b.size(); i ++){
    		if(i < a.size()) t += a[i];
    		if(i < b.size()) t += b[i];
    		c.push_back(t % 10);
    		t /= 10;
    	}
    	if(t) c.push_back(1);
    	return c;
    }
    vector<int> mul(vector<int>&a, int b){
    	vector<int> c;
    	LL t = 0;
    	for(int i = 0; i < a.size() || t; i ++){
    		if(i < a.size()) t += (LL) a[i] * b;
    		c.push_back(t % 10);
    		t /= 10;
    	}
    	return c;
    }
    bool cmp(vector<int> &a, vector<int> &b){
    	if(a.size() != b.size()) return a.size() > b.size();
    	for(int i = a.size() - 1; i >= 0; i --){
    		if(a[i] != b[i]) return a[i] > b[i];
    	}
    }
    int main(void){
    	cin >> n;
    	for(int i = 1; i <= n; i ++) cin >> w[i];
    	vector<int>temp;
    	for(int len = 3; len <= n; len ++){
    		for(int l = 1; l + len - 1 <= n; l ++){
    			int r = l + len - 1;
    			f[l][r] = vector<int>(M, 1);
    			for(int k = l + 1; k < r; k ++){
    				temp.clear();
    				temp.push_back(w[l]);
    				temp = mul(temp, w[k]), temp = mul(temp, w[r]);
    				temp = add(temp, f[l][k]), temp = add(temp, f[k][r]);
    				if(cmp(f[l][r], temp)) f[l][r] = temp;
    			}
    		}
    	}
    	for(int i = f[1][n].size() - 1; i >= 0; i --){
    		cout << f[1][n][i];
    	}
    	cout << endl;
    	return 0;
    }
    

    加分二叉树

    题目链接:戳我
    题目描述:

    在这里插入图片描述
    在这里插入图片描述

    分析

    1. f[L][R]=k 表示中序遍历是[L,R]这一段的二叉树的集合。k为这个集合分值最大值
    2. 根据根节点的位置,划分成若干类:根节点在L, L-1, …R-1, R, 如果说根节点在第k个点, f[L][R] = max(f[L][k-1]) +max(f[k+1][r]) + w[k])
    3. 问题是:如何记录方案?
    4. 开一个新的数组g[l][r],记录更新最优解时,[l, r]区间内根节点是谁。
    5. 要求最优解对应的二叉树不唯一时,输出前序遍历字典序最小的那种。即要求根节点尽可能靠左,
    #include <iostream>
    #include <algorithm>
    using namespace std;
    const int N = 50;
    int f[N][N], g[N][N];
    int w[N];
    int n;
    
    void dfs(int l, int r){
        if(l > r) return ;
        int k = g[l][r];
        printf("%d ", k);
        dfs(l, k - 1);
        dfs(k + 1, r);
    }
    
    int main(void){
        cin >> n;
        for(int i = 1; i <= n; i ++) cin >> w[i];
        for(int len = 1; len <= n; len ++){
            for(int l = 1; l + len - 1 <= n; l ++){
                int r = l + len - 1;
                for(int k = l; k <= r; k ++){
                    int left = k == l ? 1 : f[l][k-1];
                    int right = k == r ? 1 : f[k + 1][r];
                    int score = left * right + w[k];
    //该处特判不能省略,你品品这个边界情况。
                    if(l == r) score = w[k];
                    if(f[l][r] < score){
                        f[l][r] = score;
                        g[l][r] = k;
                    }
                }
            }
        }
        printf("%d\n", f[1][n]);
        dfs(1, n);
        return 0;
    }
    

    棋盘分割

    题目链接:戳我

    题目描述:
    在这里插入图片描述
    在这里插入图片描述

    分析:

    1. 我们从方差公式入手,进行化简:

    在这里插入图片描述
    目标L最小化,所有部分平方和的最小值。

    1. 不做化简,直接用公式进行处理也可。
    2. 状态表示:f[x1, y1, x2, y2, k] = m子矩阵(x1, y1),(x2, y2)(左上角和右下角)切分成k部分的所有方案。m表示方差平方的最小值。
    3. 所有状态大可分为两类:横切、纵切。这两大类中也可横切、纵切,很多种方法,每种均可选上边、下边。求出每一类的最小值,取最小值即可 。
    4. 如图所示,我们横着在x下标为i的地方横切一刀,并选择上边一部分时,这时可以看成两部分,i上部分,i下部分。想让整个最小,左边:f[x1, y1, i, y2],右部分是固定的,我们可用二维前缀和求出(二位前缀和相关知识,推荐参考这篇博客,博客链接:戳我)
    5. 循环来写的话,可能需要写好机重循环,在这里我们用记忆化搜索来操作。
    6. double数组,memset全为1或-1, double数组中的每个数均小于0.
    #include <iostream>
    #include <cstring>
    #include <cmath>
    #include <algorithm>
    using namespace std;
    const int N = 9, M = 15;
    const double INF = 1e9;
    int n, m;
    int s[N][N];
    double f[N][N][N][N][M];
    double X;//平均数
    
    int get_sum(int x1, int y1, int x2, int y2){
        return s[x2][y2] - s[x2][y1 - 1] - s[x1 - 1][y2] + s[x1 - 1][y1 - 1];
    }
    
    double get(int x1, int y1, int x2, int y2){
        double sum = get_sum(x1, y1, x2, y2) - X;
        return (double) sum *sum / n;
    }
    
    double dp(int x1, int y1, int x2, int y2, int k){
        double &v = f[x1][y1][x2][y2][k];
        if(v >= 0) return v;
        if(k == 1) return v = get(x1, y1, x2, y2);
        v = INF;
        for(int i = x1; i < x2; i ++){
            v = min(v, get(x1, y1, i, y2) + dp(i + 1, y1, x2, y2, k - 1));
            v = min(v, get(i + 1, y1, x2, y2) + dp(x1, y1, i, y2, k - 1));
        }
        for(int i = y1; i < y2; i ++){
            v = min(v, get(x1, y1, x2, i) + dp(x1, i + 1, x2, y2, k - 1));
            v = min(v, get(x1, i + 1, x2, y2) + dp(x1, y1, x2, i, k - 1));
        }
        return v;
    }
    
    
    int main(void){
        cin >> n;
        for(int i = 1; i <= 8; i ++){
            for(int j = 1; j <= 8; j ++){
                cin >> s[i][j];
                s[i][j] += s[i - 1][j] + s[i][j - 1]-s[i - 1][j - 1];
            }
        }
        X = (double) s[8][8] / n;
        memset(f, -1, sizeof f); //负数
        printf("%.3lf\n", sqrt(dp(1, 1, 8, 8, n)));
        return 0;
    }
    
    展开全文
  • 分值语句结构

    2018-03-30 19:37:50
    结构有 :  顺序结构  选择结构  循环结构 if 语句 1.if语句的书写规范 bool值与零比较:0表示假,非0表示真; if(flag==TURE),这样的 语法结构会... 建议for语句的循环控制变量的取值采用“半开半闭区间”写法。

    结构有 :

             顺序结构

            选择结构

            循环结构

    if  语句

    1.if语句的书写规范

    bool值与零比较:0表示假,非0表示真;


    if(flag==TURE),这样的 语法结构会出现错误,比如(flag=5)

    所以  应该用if(flag)或if(!flag)。


    整形变量与零的比较。


    可以写成if(number == 0)

                 if(0 == number )  ; 防止书写错误。

    指针和零比较

      首先必须初始化  如 int *p = NULL;(不初始化的话是个随机值)。

    比较if(p != NULL)


    浮点型和零值得比较


    double i =2.0;

    if(i * 2.0 == 4)

     //这种写法是错误的

    因为浮点型在内存中的存储方式使得,有些浮点数在内存无法精确的存储,这样就必然有精度的丢失。

    必须要设置一个精度范围,保证误差在精度范围内。

     例 ;#denfine EXP 0.0001;

    float i =20.0;

    if(f-20.0>EXP && f-20.0<EXP)

    {

    }


    关于getchar()和putchar

    char ch  = getchar();

    putchar(ch)

    这样是得不到你想要的结果;getchar从缓冲区得到字符,但是缓冲区还有“\n"所以putchar 得到“\n”。

    应用while(ch=getchar()!= '\n');

    {

    getchar();

    }

    putchar; 

    或者刷新缓冲区(fflush(stdin);)

    2.switch语句

    在switch 语句中,必须搭配break才能实现真正的分支,最好每个switch语句中都加一个dafault(默认)。

    3.goto 语句(适合个别场景,不要乱用)  

     for()

      for()

    {

        for()

    {if (disaster)

    goto error;

    }

    error:

           if(disater)

    //处理错误

    4.while语句

    遇到break就停止后期所有的循环,直接终止循环。

    所以while中的break是用于永久终止循环的。

    遇到continue终止本次循环,直接while语句的判断部分。进行下一次循环的入口。

      

    5.for循环

       不要在for循环体内修改循环变量,防止for循环失去控制。

       建议for语句的循环控制变量的取值采用“半开半闭区间”写法。






    展开全文
  • 区间dp

    2020-09-17 10:18:33
    文章目录区间dp1. 算法分析2. 算法模板3. 典型例题3.1 线性石子合并问题3.2 环型石子合并问题3.3 多边形划分三角形问题3.3.1 求面积3.3.2 求方案数3.4 子树划分问题3.5 二维分割问题 区间dp 1. 算法分析 算法思想 ...
  • 量异常分值计算模型

    2019-06-06 15:09:33
    量异常分值计算模型 基线X (1)30日全日志,计算其每小时访问次数,将所有项累加后取项平均值,得出降噪后的每小时平均次数作为基线M; (2)30日每日日志,重复一过程计算每日每小时次数作为参考值; (3)利用...
  • 使用开区间分值范围 在默认情况下,ZRANGEBYSCORE命令和ZREVRANGEBYSCORE命令接受的分值范围都是闭区间分值范围,也就是说,分值等于用户给定最大分值或者最小分值的成员也会被包含在结果当中。 举个例子,如果我们...
  • 策略:紧着最大分值换。 最大斜率问题 ,给出n个点的坐标(笛卡尔坐标) 求(A[i]-A[j])/(i-j)最大 策略:相邻的坐标中找到最大斜率 区间选取 (会场安排问题),给一个大区间l,r然后给你n个区间,最...
  • g[l][r]表示当前区间l,r之间最大分值的根节点是谁。用于之后的前序遍历输出。(前序遍历:根-左-右)(中序遍历:左-根-右) 当区间长度为1时,根节点没有左右儿子,故它的得分就为它自己本身。 当区间长度大于1时...
  • 51nod 1672 区间交(贪心)

    2017-10-22 17:00:26
    1672 区间交基准时间限制:1 秒 空间限制:131072 KB 分值: 40 难度:4级算法题 收藏 关注小A有一个含有n个非负整数的数列与m个区间,每个区间可以表示为li,ri。它想选择其中k个区间, 使得这些区间的交的...
  • 51Nod 1672 区间

    2017-10-27 10:59:09
    基准时间限制:1 秒 空间限制:131072 KB 分值: 40 难度:4级算法题  收藏  关注 小A有一个含有n个非负整数的数列与m个区间,每个区间可以表示为li,ri。 它想选择其中k个区间, ...
  • 51nod 1672 区间

    2017-05-16 17:13:17
    基准时间限制:1 秒 空间限制:131072 KB 分值: 40 难度:4级算法题 收藏 关注 小A有一个含有n个非负整数的数列与m个区间,每个区间可以表示为li,ri。 它想选择其中k个区间, 使得这些区间的交的那些位置所对应的...
  • 蓝桥杯 子串分值和 最详细题解

    千次阅读 2021-04-08 21:53:20
    蓝桥杯 子串分值和 最详细题解 #include<iostream>//这是看过一个大佬的写的,改写的 #include<algorithm> #include<cstring> #define ll long long using namespace std; const int maxn=2e5+10...
  • 用差分实现树状数组的区间查询,区间修改
  • 1810 连续区间(分治)

    2017-10-07 16:40:00
    基准时间限制:1.5秒 空间限制:131072KB 分值:80难度:5级算法题 区间内所有元素排序后,任意相邻两个元素值差为1的区间称为“连续区间” 如:3,1,2是连续区间,但3,1,4不是连续区间 给出一个1~n的排列,...
  • 51Nod-1672-区间

    2017-10-30 18:58:25
    基准时间限制:1 秒 空间限制:131072 KB 分值: 40 难度:4级算法题  收藏  关注 小A有一个含有n个非负整数的数列与m个区间,每个区间可以表示为li,ri。 它想选择其中k个区间, ...
  • 我们知道参数的置信区间的计算,这些都服从一定的分布(t分布、正态分布),因此在标准误前乘以相应的t分值或Z分值。但如果我们找不到合适的分布时,就无法计算置信区间了吗?幸运的是,有一种方法几乎可以用于计算...
  • 区间中最大的数 RMQ

    2017-08-22 16:13:10
    1174 区间中最大的数 基准时间限制:1 秒 空间限制:131072 KB 分值: 0 难度:基础题 给出一个有N个数的序列,编号0 - N - 1。进行Q次查询,查询编号i至j的所有数中,最大的数是多少。 例如: ...
  • 威尔逊区间

    千次阅读 2019-06-13 21:55:44
    1927年,美国数学家 Edwin Bidwell Wilson提出了一个修正公式,被称为"威尔逊区间",地解决了小样本的准确性问题。 在上面的公式中,表示样本的"赞成票比例",n表示样本的大小,表示对应某个置信水平的z统计量,这...
  • 51 nod 1495 中国好区间

    2019-09-23 16:38:20
    基准时间限制:0.7秒 空间限制:131072KB 分值:80难度:5级算法题 阿尔法在玩一个游戏,阿尔法给出了一个长度为n的序列,他认为,一段好的区间,它的长度是>=k的,且该区间的第k大的那个数,一定...
  • 51nod-1672 区间

    2016-10-05 16:14:56
    基准时间限制:1 秒 空间限制:131072 KB 分值: 40 难度:4级算法题  收藏  关注 小A有一个含有n个非负整数的数列与m个区间,每个区间可以表示为li,ri。 它想选择其中k个区间, ...
  • 对于一个字符串 SSS,我们定义 SSS 的分值 f(S)f(S)f(S) 为 SSS 中恰好出现一次的字符个数。 例如 f(“aba”)=1f(“aba”)=1f(“aba”)=1,f(“abc”)=3f(“abc”)=3f(“abc”)=3,f(“aaa”)=0f(“aaa”)=0f(“aaa...
  • 威尔逊置信区间算法

    万次阅读 2020-03-23 17:26:52
    二项分布计算置信区间有多种计算公式,最常见的是“正太区间”(Normal approximation interval),但它只适用于样本较多的情况(np > 5 且 n(1 − p) > 5),对于小样本,它的准确性很差。Wilson算法正是解决...
  • 基准时间限制:1秒 空间限制:131072KB 分值:10难度:2级算法题 收藏 关注 一整数数列a1, a2, ... , an(有正有负),以及另一个整数k,求一个区间[i, j],(1 <= i <= j <= n),使得a[i] + .....
  • poj1651 区间dp

    2016-03-04 11:01:38
    题目大意:每次从中间(取出两边)序列中取出一个数,则它的分值是它乘以与它相邻的两数,求去玩所有的中间数后分值和最小为多少 思路:区间dp,dp[i][j]表示从i到j的最优解,枚举从i到j最后移除的元素,有dp[i][j] = ...
  • 基准时间限制:1 秒 空间限制:131072 KB 分值: 40 难度:4级算法题  收藏  关注 小A有一个含有n个非负整数的数列与m个区间,每个区间可以表示为li,ri。 它想选择其中k个区间, ...
  • 51nod 1495 中国好区间

    2017-04-06 22:46:54
    基准时间限制:0.7 秒 空间限制:131072 KB 分值: 80 难度:5级算法题  收藏  关注 阿尔法在玩一个游戏,阿尔法给出了一个长度为n的序列,他认为,一段好的区间,它的长度是>=k的,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 6,643
精华内容 2,657
关键字:

区间分值