精华内容
下载资源
问答
  • 区间离散对数问题的改进方法。
  • #对数分布的置信区间 #sigma已知u的1-α置信区间 duishuci1 <-function(n,mu,sigma,alpha) { x=rlnorm(n,mu,sigma) shuzhou <-sum(log(x))/n mucimin <-shuzhou-sigma*(n**(-1/2))*qnorm(alpha/2,0,1,...

    参考论文

    [1]于洋.对数正态分布的几个性质及其参数估计[J].廊坊师范学院学报(自然科学版),2011,11(05):8-11.

    代码

    #对数分布的置信区间
    #sigma已知u的1-α置信区间
    
    duishuci1 <-function(n,mu,sigma,alpha) {
      x=rlnorm(n,mu,sigma)
      shuzhou <-sum(log(x))/n 
      mucimin <-shuzhou-sigma*(n**(-1/2))*qnorm(alpha/2,0,1,lower.tail = FALSE)
      mucimax <-shuzhou+sigma*(n**(-1/2))*qnorm(alpha/2,0,1,lower.tail = FALSE)
      return(c(mucimin,mucimax))
    }
    
    duishuci1(1000,1,1,0.05)
    
    #都未知
    
    duishuci2 <-function(n,mu,sigma,alpha) {
      x=rlnorm(n,mu,sigma)  #这个随机数生成的是sigma的,不像正态生成sigma平方
      y=log(x)
      ybar=mean(y)
      sy=sd(y)
      sy2=sy**2
      mucimin <-ybar-sy*qt(alpha/2,n-1,lower.tail = FALSE)/sqrt(n)
      mucimax <-ybar+sy*qt(alpha/2,n-1,lower.tail = FALSE)/sqrt(n)
      sigmacimin <- n*sy2/qchisq(alpha/2,n-1,lower.tail = FALSE)
      sigmacimax <- n*sy2/qchisq(1-alpha/2,n-1,lower.tail = FALSE)
      return(c(mucimin,mucimax,sigmacimin,sigmacimax))
      
    }
    
    duishuci2(1000,0,3,0.05)
    
    
    展开全文
  • 论文研究-对数正态分布下未来区间内故障次数的单样预测.pdf, 基于产品寿命评估与预测理论, 研究了对数正态分布下未来区间内故障次数的单样预测问题. 引入胜算比, 给出了...
  • 静态区间逆序对数查询,这道题用线段树貌似不好做,可以把区间分成$\sqrt n$块,预处理出两个数组:$sum[i][j]$和$inv[i][j]$,$sum[i][j]$表示前i个块中小于等于j的数的个数,$inv[i][j]$表示第i块与第j块之间的...

    题目链接

    静态区间逆序对数查询,这道题用线段树貌似不好做,可以把区间分成$\sqrt n$块,预处理出两个数组:$sum[i][j]$和$inv[i][j]$,$sum[i][j]$表示前i个块中小于等于j的数的个数,$inv[i][j]$表示第i块与第j块之间的逆序对数,递推搞一下就行。查询的时候中间的部分直接查询,两边多出来的部分暴力计算贡献即可。总复杂度$O(n\sqrt nlogn)$

     1 #include<bits/stdc++.h>
     2 using namespace std;
     3 typedef long long ll;
     4 const int N=5e4+10,sqrtN=226,inf=0x3f3f3f3f;
     5 int a[N],b[N],c[N],n2,in[N],L[sqrtN],R[sqrtN],n,m,sqrtn,nb;
     6 int sum[sqrtN][N],inv[sqrtN][sqrtN];
     7 void add(int u,int x) {for(; u<=n2; u+=u&-u)c[u]+=x;}
     8 int get(int u) {int ret=0; for(; u; u-=u&-u)ret+=c[u]; return ret;}
     9 int main() {
    10     scanf("%d",&n),sqrtn=sqrt(n+0.5);
    11     for(int i=1; i<=n; ++i)scanf("%d",&a[i]);
    12     for(int i=1; i<=n; ++i)b[i-1]=a[i];
    13     sort(b,b+n),n2=unique(b,b+n)-b;
    14     for(int i=1; i<=n; ++i)a[i]=lower_bound(b,b+n2,a[i])-b+1;
    15     for(int i=1; i<=n; ++i) {nb=in[i]=i/sqrtn+1; if(!L[in[i]])L[in[i]]=i; R[in[i]]=i;}
    16     for(int i=1; i<=nb; ++i) {
    17         for(int j=L[i]; j<=R[i]; ++j)sum[i][a[j]]++;
    18         for(int j=2; j<=n; ++j)sum[i][j]+=sum[i][j-1];
    19         for(int j=1; j<=n; ++j)sum[i][j]+=sum[i-1][j];
    20     }
    21     for(int i=1; i<=nb; ++i) {
    22         for(int j=R[i]; j>=L[i]; --j)inv[i][i]+=get(a[j]-1),add(a[j],1);
    23         for(int j=R[i]; j>=L[i]; --j)add(a[j],-1);
    24     }
    25     for(int i=1; i<=nb; ++i)
    26         for(int j=i+1; j<=nb; ++j) {
    27             for(int k=L[j]; k<=R[j]; ++k)inv[i][j]+=(R[j-1]-L[i]+1)-(sum[j-1][a[k]]-sum[i-1][a[k]]);
    28             inv[i][j]+=inv[i][j-1]+inv[j][j];
    29         }
    30     scanf("%d",&m);
    31     for(int ans=0; m--;) {
    32         int l,r;
    33         scanf("%d%d",&l,&r),l^=ans,r^=ans,ans=0;
    34         if(in[l]==in[r]) {
    35             for(int i=r; i>=l; --i)ans+=get(a[i]-1),add(a[i],1);
    36             for(int i=r; i>=l; --i)add(a[i],-1);
    37         } else {
    38             int lb=in[l]+1,rb=in[r]-1;
    39             if(lb<=rb) {
    40                 ans+=inv[lb][rb];
    41                 for(int i=r; i>=L[in[r]]; --i)ans+=(R[rb]-L[lb]+1)-(sum[rb][a[i]]-sum[lb-1][a[i]]);
    42                 for(int i=R[in[l]]; i>=l; --i)ans+=sum[rb][a[i]-1]-sum[lb-1][a[i]-1];
    43             }
    44             for(int i=r; i>=L[in[r]]; --i)ans+=get(a[i]-1),add(a[i],1);
    45             for(int i=R[in[l]]; i>=l; --i)ans+=get(a[i]-1),add(a[i],1);
    46             for(int i=r; i>=L[in[r]]; --i)add(a[i],-1);
    47             for(int i=R[in[l]]; i>=l; --i)add(a[i],-1);
    48         }
    49         printf("%d\n",ans);
    50     }
    51     return 0;
    52 }

     

    转载于:https://www.cnblogs.com/asdfsag/p/10700744.html

    展开全文
  • 给定\(n\)个数,\(q\)个询问,每次询问\([l,r]\)区间内的逆序对数。 强制在线。 思路 参考:http://www.cnblogs.com/candy99/p/6579556.html 离线的话就如上一题bzoj 3289 Mato的文件管理,可以直接用 莫队 搞,在线...

    题目链接

    题意

    给定\(n\)个数,\(q\)个询问,每次询问\([l,r]\)区间内的逆序对数。

    强制在线。

    思路

    参考:http://www.cnblogs.com/candy99/p/6579556.html

    离线的话就如上一题bzoj 3289 Mato的文件管理,可以直接用 莫队 搞,在线的话怎么办呢?

    分块大法好。

    1

    预处理出两个信息:

    1. \(f[i][j]\):从 第\(i\)块开始位置 到 位置\(j\) 这段区间的逆序对数
    2. \(s[i][j]\):前\(i\)块中\(\leq j\)的数字总数

    2

    有了这两个信息之后怎么用呢?

    考虑一个询问\([l,r]\)
    首先,如果左右端点在同一段内,直接暴力即可,
    否则,将其拆成三段看待:

    -------------------------------------------------
    | ① |           ②                   |   ③       |
    l   l所在块的右端点                r所在块的左端点   r

    如上图,
    逆序对数=
    ①中的逆序对数+②中的逆序对数+③中的逆序对数+
    ①与②间的逆序对数+①与③间的逆序对数+②与③间的逆序对数

    根据上面预处理出的信息\(f\)
    即能直接得到(②+③)一整段的逆序对数,
    即②中的逆序对数+③中的逆序对数+②与③间的逆序对数,
    复杂度\(O(1)\)

    因此,另外要求的就是,
    ①中的逆序对数+①与②间的逆序对数+①与③间的逆序对数

    其中,
    ①中的逆序对数 及 ①与③间的逆序对数 可以直接树状数组暴力算,
    \(\sqrt n\)次插入,\(2*\sqrt n\)次查询,复杂度\(O(\sqrt n*logn)\)

    ①与②间的逆序对数 则需枚举①中的每个数,然后用预处理出的另一个信息\(s\)
    复杂度\(O(\sqrt n*1)\)

    3

    最后再来讨论一下该如何预处理这两个信息。

    \(f[i][j]\):从 第\(i\)块开始位置 到 位置\(j\) 这段区间的逆序对数
    对每一块做一次树状数组,复杂度:\(2*(\sqrt n+2\sqrt n+\cdots+n)*logn=O(n\sqrt nlogn)\)

    \(s[i][j]\):前\(i\)块中\(\leq j\)的数字总数
    算每一块时,充分利用前缀和思想,先算第\(i\)块中\(= j\)的数字总数,再算第\(i\)块中\(\leq j\)的数字总数,最后算前\(i\)块中\(\leq j\)的数字总数,复杂度:\(O(n\sqrt n)\)

    Code

    #include <bits/stdc++.h>
    #define F(i, a, b) for (int i = (a); i < (b); ++i)
    #define F2(i, a, b) for (int i = (a); i <= (b); ++i)
    #define dF(i, a, b) for (int i = (a); i > (b); --i)
    #define dF2(i, a, b) for (int i = (a); i >= (b); --i)
    #define maxn 50010
    #define maxb 310
    using namespace std;
    typedef long long LL;
    int a[maxn], mp[maxn], c[maxn], cnt[maxb][maxn], bl[maxn];
    int n, m, nn, num, blo;
    struct node { int l, r; }b[maxb];
    int f[maxb][maxn];
    inline int read(){
        char c=getchar();int x=0,f=1;
        while(c<'0'||c>'9'){if(c=='-')f=-1; c=getchar();}
        while(c>='0'&&c<='9'){x=x*10+c-'0'; c=getchar();}
        return x*f;
    }
    inline int lowbit(int x) { return x & -x;}
    inline int query(int x) { int ret=0; while (x) ret += c[x], x-=lowbit(x); return ret; }
    inline void add(int x, int v) { while (x<=nn) c[x] += v, x+=lowbit(x); }
    void init(int s) {
        b[s].l=s*blo, b[s].r=(s==num-1?n:b[s].l+blo);
        memset(c, 0, sizeof c);
        F(i, b[s].l, n) {
            f[s][i] = f[s][i-1] + i-b[s].l-query(a[i]);
            add(a[i], 1);
        }
        F(i, b[s].l, b[s].r) ++cnt[s][a[i]];
        F2(i, 1, nn) cnt[s][i] += cnt[s][i-1];
        F2(i, 1, nn) cnt[s][i] += cnt[s-1][i];
    }
    int ask(int l, int r) {
        int ret=0;
        if (bl[l]==bl[r]) {
            memset(c, 0, sizeof c);
            F2(i, l, r) {
                ret += i-l-query(a[i]);
                add(a[i], 1);
            }
        }
        else {
            ret += f[bl[l]+1][r];
            memset(c, 0, sizeof c);
            F(i, l, b[bl[l]].r) {
                ret += i-l-query(a[i]);
                add(a[i], 1);
                ret += cnt[bl[r]-1][a[i]-1]-cnt[bl[l]][a[i]-1];
            }
            int ex=b[bl[l]].r-l;
            F2(i, b[bl[r]].l, r) ret += ex-query(a[i]);
        }
        return ret;
    }
    int main() {
        scanf("%d", &n); blo = sqrt(n);
        F(i, 0, n) a[i]=mp[i]=read(), bl[i]=i/blo;
        sort(mp, mp+n);
        nn = unique(mp, mp+n)-mp;
        F(i, 0, n) a[i] = lower_bound(mp, mp+nn, a[i])-mp+1;
        num = bl[n-1]+1;
        F(i, 0, num) init(i);
        int lastans=0;
        scanf("%d", &m);
        F(i, 0, m) {
            int l=read(),r=read();
            l^=lastans, r^=lastans;
            --l, --r; if (l>r) swap(l, r);
            if (l<0||r>=n) continue;
            printf("%d\n", lastans=ask(l,r));
        }
        return 0;
    }
    

    转载于:https://www.cnblogs.com/kkkkahlua/p/8484383.html

    展开全文
  • 题意: 有一个1-n的全排列,m个询问,某个区间的整除对对数(1-1,2-4,1-2) 解析: 首先可以简单的得出下标1~i内的对数:枚举每个数的倍数,标记位置较大的那个,再做前缀和。 区间[L,R][L,R][L,R]的对数=[1,R]−...

    原题: http://codeforces.com/problemset/problem/301/D

    题意: 有一个1-n的全排列,m个询问,某个区间的整除对对数(1-1,2-4,1-2)

    解析:

    首先可以简单的得出下标1~i内的对数:枚举每个数的倍数,标记位置较大的那个,再做前缀和。

    区间[L,R][L,R]的对数=[1,R][1,L1]([1,L1][L,R])[1,R]-[1,L-1]-([1,L-1]与[L,R]之间)。现在就是处理这个之间的影响。

    从小到大for,有一对[i,r][i,r],则树状数组r++r++,这个就是[1,L1][1,L-1]的影响。那么[1,L1][1,L-1][L,R][L,R]的影响就是Query(R)Query(L1)Query(R)-Query(L-1)

    #include<bits/stdc++.h>
    using namespace std;
    
    const int maxn=2e5+5;
    int sum[maxn];
    int pos[maxn];
    vector<int>R[maxn];
    int tr[maxn];
    void add(int p,int v,int n){
        while(p<=n){
            tr[p]+=v;
            p+=p&-p;
        }
    }
    int query(int p){
        int res=0;
        while(p){
            res+=tr[p];
            p-=p&-p;
        }
        return res;
    }
    
    struct node{
        int l,r,id;
        bool operator<(const node &R)const{
            return l<R.l;
        }
    }e[maxn];
    int sub[maxn];
    
    int main(){
        int n,m;scanf("%d%d",&n,&m);
        for(int i=1,tmp;i<=n;i++)scanf("%d",&tmp),pos[tmp]=i;
        for(int i=1;i<=n;i++){
            for(int j=i;j<=n;j+=i){
                if(pos[j]){
                    int l=min(pos[i],pos[j]),r=max(pos[i],pos[j]);
                    R[l].push_back(r);
                    sum[r]++;
                }
            }
        }
        for(int i=1;i<=n;i++)sum[i]+=sum[i-1];
    
        for(int i=1;i<=m;i++)scanf("%d%d",&e[i].l,&e[i].r),e[i].id=i;
        sort(e+1,e+1+m);
        int ar=1;
        for(int i=1;i<=n;i++){
            while(ar<=m&&e[ar].l==i)
                sub[e[ar].id]=query(e[ar].r)-query(e[ar].l-1),++ar;
            for(int j=0;j<R[i].size();j++)
                add(R[i][j],1,n);
        }
        for(int i=1,l=e[1].l,r=e[1].r; i<=m; ++i,l=e[i].l,r=e[i].r)
            sub[e[i].id]=sum[r]-sum[l-1]-sub[e[i].id];
        for(int i=1;i<=m;i++)
            printf("%d\n",sub[i]);
    }
    
    
    展开全文
  • 给定\(n\)个数,\(q\)个询问,每次询问\([l,r]\)区间内的逆序对数。 思路 莫队+树状数组 注意离散化 Code #include <bits/stdc++.h> #define F(i, a, b) for (int i = (a); i < (b); ++i) #define F2(i, a,...
  • 题目大意:有n个数,求区间L,R的个数使得该区间内所有数或的值小于m.的区间[L, R]的个数,L<=R。 思路: 因为数字或完之后,只可能大于等于本身,不可能变小,因为1|1=1 ; 1|0 = 1; 0|0 = 0; 所以我们可以用尺取法...
  • 题目链接:...题意:求1~ b与1 ~ d之间gcd=k的数对数。两数互换视为同一组。 思路:求(1,b)与(1,d)之间gcd=k的对数等于求区间1:(1,b/ k)与区间2:(1,d/ k)之间互素的数的...
  • Mato每天随机选一个区间[l,r],他今天就看编号在此区间内的这些资料。Mato有一个习惯,他总是从文件大小从小到大看资料。他先把要看的文件按编号顺序依次拷贝出来,再用他写的排序程序给文件大小排序。排序程序可以...
  • 给你n个数,m个询问,问你l到r区间内有多少对数互为因倍数:4 2就有3对,4,4和2,2和4,2。 题解: 蛮难想的。 我先处理出从1到每个位置有多少对数。可以从前往后做,也可以从后往前做,我是从后往前做,一开始所有个...
  • 给一个1-n的排列的序列,m次询问,每次询问区间L—R之间内有多少个整除数对。 思路: 首先需要解决统计整除数对的问题,如果1-n是有序的序列,那么很好统计,每次将i加上i一直加到n,每次加到的数即是i的倍数,这...
  • 解题思路:求两个区间内gcd(x,y) = k,那么x/k与y/k互质,即求区间[1,b/k]与[1,d/k]内有多少对数互质,可以先求一个数与某个区间互质的数的个数 。 #include #include #include #include using namespace std; ...
  • (1,b/k)(1,d/k)转化为互质对数 设F(k)为gcd(x,y)为k的倍数的对数->F(k)=(b/k)*(d/k) f[1]=mu[1]*F[1]+mu[2]*F[2]+...mu[m]*F[m] 再减去重复计算的,变了F[i]再做一遍== 1 #include<stdio.h> 2 #...
  • 求符合某对严格递增序列对数 求反面即可 用到了每一个序列的minn maxx 每一个序列是否本身递增flag[i]=1 跳过 求不递增的序列 我的minn>=以我的minn及之前的数作为maxx的序列个数 #include<bits/stdc++.h> ...
  • 题意: x∈[l1,r1],y∈[l2,r2]x\in[l1,r1],y\in[l2,r2]x∈[l1,r1],y∈[l2,r2],求gcd(x,y)=1的对数 解析: 莫比乌斯函数,定义g(x)表示gcd=x的对数,定义f(x)=∑g(ix)f(x)=\sum g(ix)f(x)=∑g(ix),那么g(x)=∑μ(i)...
  • 1 点估计 2 基于截尾样本的最大似然估计 3 估计量的评选标准 4 区间估计 5 正态总体均值与方差的区间估计 6 (0-1)分布参数的区间估计 7 单侧置信区间
  • 那么我们将其扩展到1-n区间内,就是求[1,n/p]的欧拉函数值,但是我们需要求的是sigmaEualr(n/p)的前缀和,因为y是从1-n之间取的,所以对数就是sum[n/p]*2-1,因为是对数,而且还有重复的情况(自身是素数的情况) ...
  • 对数函数是指 这里 对数函数的性质主要有定义域是 值域是 当 时单调递增,当 时单调递减。过定点 关于指数和对数的运算,在过去的文章里已经说得很...这是很直观的结论,首先单调函数肯定是单射,其次如果区间上的连...
  • 区间[l,r]内有多少对k生互斥数对数,所谓k生互斥数即(y-k,y+k)互斥,且两个数都在区间内 注意:l,r可以从0开始!数据范围比较大,要转换思维,普通方法会超时 解题思路 (终于把大佬的代码看懂了!!(;´...
  • 要求:生成的目标对数正态分布随机数要介于区间[log_lower,log_upper]内,这里设定该区间为[5, 10],并绘制正态分布与对数正态分布随机数的直方图。源代码:import numpy as npfrom pylab import...
  • =1)叫做对数函数,它的定义域是区间(0,+∞)。把指数函数y=a^x的x看作因变量,y看作自变量,就得到了一个新的函数,这个新的函数就是对数函数,指数函数称为对数函数的直接函数。例1 绘制底为2的对数函数,观察图像...
  • 数据取对数的意义

    2021-04-07 12:44:14
    数据取对数的意义 平时在一些数据处理中,经常会把原始数据取对数后进一步处理。 之所以这样做是基于对数函数在其定义域内是单调增函数,取对数后不会改变数据的相对...3. 某些情况下,在数据的整个值域中的在不同区间

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,492
精华内容 596
关键字:

对数区间