精华内容
下载资源
问答
  • 另外种我们称为叫1对N,应用在规模化的场景应用中,个比方你光顾一家服务,你可能办了贵宾卡,那么我们可以不用报名字,也不用掏VIP卡,到门口刷一下脸他就知道是哪位,交易完成后自动扣钱。...

    金融科技火热无比时,支付场景下的风控可以怎么做?(下)

    金融中的人脸识别,主要用途分两种:一种是身份核验,即一对一。其实你已经知道了你当前操作的这个待核验人的身份,接下来只要对这个身份和这个人之间进行一个信息核验。;另外一种我们称之为叫1对N,应用在规模化的场景应用中,打个比方你光顾一家服务,你可能办了贵宾卡,那么我们可以不用报名字,也不用掏出VIP卡,到门口刷一下脸他就知道是哪一位,交易完成后自动扣钱。这样一个场景因为实际上谁也没有说出谁是谁,但在这样1:N的的情况下应用,它可以对于不清楚的目标对象进行了检索然后找到了正确的目标对象。

    其实在远程身份核验的业务场景中,所使用的技术不只人脸识别一项。任何一个技术落地到一个实际应用时,实际上是一种综合的技术解决方案的应用。比如说在1对1的识别中最常用的辅助技术:身份证文字内容识别(身份证OCR)。还有一些行业特殊性问题的解决,以手机刷脸为例,需要解决的一个问题是防止用户在用照片伪造刷脸,我们称之为活体识别,需要判断进行刷脸的是一个真人还是一个照片还是一个视频。

    很多人可能会问,人脸识别的技术水平到达一个什么样的程度了?其实,现在在金融行业进行这样的认证支付,其安全性已经非常高了。单纯从人脸识别这一点上来讲,现在比较常用的是把通过率、便捷性控制在90%或者是95%,去看误识率、安全性。

    有人说为什么不设到99%,我们可以设到99%,但是99%对安全性会有影响,这两个指标会有冲突,金融行业要求在便捷性可接受的情况下安全性越高越好。

    声纹指纹虹膜等多生物特征融合认证

    是不是意味着说人脸识别就已经可以完全取代银行卡密码甚至达到一个更高的安全性呢?非也。

    科大讯飞云平台事业部人脸声纹技术主管李繁表示,以人脸识别的技术来说,在最新的DFDR算法下面,人脸的分辩能力已经达到了99.47%的状态。但是在实际的应用中仍然面临着一些挑战——比如当面对一位韩国小姐的时候。当然,声纹技术同样也有应用上的一些挑战,比如说声纹易变形,易受身体状况,年龄,情绪等的影响;实际应用中也可能会受到录音设备的影响,所以作为一个单一的生物特征都有各己的不稳定性。

    为应对支付领域的一个高安全性需求,也为了解决单一生物特征存在的一个不稳定性,业内提出了多生物特征融合认证解决方案,从不同维度对两种生物特征进行融合计算。

    早前国际生物特征组织分别从干扰用户程度,独立性,费用代价,易用性这四个层面对市场上在用的生物特征进行了一个系统的统计分析,分析包括掌纹识别,签名识别,指纹识别,语音识别,虹膜识别,视网膜识别,脸部识别以及温谱识别。

    理想的生物特征系统当然是要具备高独特性,高易用性,对用户干扰程度低,且费用代价低,从这里可以看出,在人类认知的范围内的声纹识别,人脸识别技术以及人类认知范围内的指纹识别,虹膜识别,和掌纹识别,为何能在各自的领域中发挥着重要的作用。

    其中,声纹识别技术和人脸识别技术能够被用作便捷的身份认证形式,与其拥有的特点是分不开的,首先这些生物特征与生俱来的,而且它都具备唯一性,不易被复制。其次这些特征都是易采集,且采集隐蔽性较强,还能够被远程操作。

    以声纹技术来说,声纹是根据语音波形中反映说话人心理和行为特征的语音参数,自动识别说话人身份,每个人无论别人说话模仿的多么相似,他都具有独一无二的声纹。这是由每个人的发声器官在成长过程中形成的,这个唯一性能够唯一确定一个用户的身份。

    目前,声纹识别模式对外支持了声纹自由说、动态数字密码、开放文本密码、固定文本密码。在金融支付中,动态数字密码因其使用便捷性,目前也成为最为广泛的声纹识别模式,当然它其他三种模式也有相应的适用场景。

    在这个领域中声纹识别主要用途分为两种,与人脸识别相似,一是声纹确认,一比一比对,二是声纹鉴别一比N比对。

    而相信大家最好奇的是这个声纹模型建立和配对的过程,究竟是怎样的原理,能够用算法和代码来量化一个人的声音。李繁告诉雷锋网(公众号:雷锋网),就科大讯飞来说,其使用了混合高斯-通用背景模型(GMM-UBM),是基于高速混合模型的说话人系统,是说话人识别中的主流算法。

    然而,基于生理特征的生物识别技术存在以下几个先天性缺陷:一、成本高昂,通常需要专门的硬件支持;二、容易泄露和仿冒,安全性低;三、应用不当后果严重,一旦泄露身份信息几乎无法更改。所以,生物特征识别除了基于人体本身的生物对象进行安全监控,业内人士也在研究基于击键等行为类生物特征进行识别的方式。

    击键过程看似简单,实际上却非常复杂,需要很多肌肉的高度配合。久而久之,就形成了一种固定的习惯,这种习惯会在击键的时间和压力上有所反映。

    研究者表示,具体的应用中,自由文本的击键特征识别和固定文本的击键特征识别也有所不同。对于固定文本而言,一般长度较短,用户键入固定文本时所表达的击键特征受限制条件影响较大,最终的击键形态也与限制条件有着紧密的联系。这种情况下,可以直接存储和比对击键形态……对于自由文本而言,其内容和长度不受限制,限制条件对于最终击键形态的影响可能十分有限。这种情况下,可以通过两个方面辨识用户的击键特征样本:一是限制条件;二是传统的自由文本击键特征识别算法。限制条件即与数据库存储进行比对;自由文本击键特征识别算法也有许多现成方案,比如,曼哈顿距离、欧氏距离、神经网络、相对熵等等。

    但也有用户觉得,击键特征是个伪命题,因为不同键盘实现的标准不同,键程、弹力都会受到影响。事实上,每一种技术都有缺陷,我们能做的是不断优化,或以多种方式弥补配合。




    本文作者:温晓桦
    本文转自雷锋网禁止二次转载,原文链接
    展开全文
  • 题目大意:给出n个柱子,问若按照规则摆放,最多能放多少个球,规则如下: 每次只能在某根柱子的最上面放球 在同根柱子中,任何2个相邻球的编号和为完全平方数 并输出方案 题目分析:知道是最大流但却不知道...

    题目链接:点击查看

    题目大意:给出n个柱子,问若按照规则摆放,最多能放多少个球,规则如下:

    1. 每次只能在某根柱子的最上面放球
    2. 在同一根柱子中,任何2个相邻球的编号之和为完全平方数

    并输出方案

    题目分析:知道是最大流但却不知道该怎么建图。。太菜了,感觉这种隐式图比正常图更难搞,虽然是属于网络流的题目,好像贪心也可以搞一搞,但还是老老实实练练怎么建图吧

    对于这个题目而言,其实可以将其抽象成二分图的模型,建好图后就可以直接用最小路径覆盖的定理了:

    给定一张有向无环图,要求用尽量少的不相交的简单路径,覆盖有向无环图的所有顶点(也就是每个顶点恰好被覆盖一次)。公式:最小路径覆盖=顶点数-二分图最大匹配(无向图需要除以2)

    对于有关系的点我们可以建有向边,然后判断能否将所有的点分成互不相连的尽可能少的单链,这样一来,就可以将每一条单链放在一个柱子上,就可以符合题意了

    在实现上述操作的过程中,我们可以选择不断增加当前球的数量,从而在建边后反复跑最大流,但如果每次都重新跑最大流的话肯定会超时,为了防止超时,我们可以每次都在残余网络上跑,这样跑出来的答案就是在加上当前球后多跑的流量了,最大流跑出来的答案就是二分图最大匹配,这样只要满足最小路径覆盖的答案小于等于柱子的个数就好了,稍微想一下这个关系

    这样显然对于每个点我们需要进行拆点处理,每次新增加一个球,在网络流建图时我们就让他的入点为2*num,出点为2*num+1,如果某个编号x与其之前的编号y可以相邻,我们就让y对x建边,边权为1就好了,跑完网络流后相当于完成了二分图最大匹配,就能直接得到能放多少个球了

    至于另一个子问题,也就是打印路径,在我看来反而比求最大流还要难,这里我选择的是数组模拟链表的方式记录一下其之间的关系,也就是哪些球是可以相邻的,在跑完最大流后的残余网络中,两个点(源点和汇点除外)相连的正向边,若边权为0说明这条边为最大流做出了贡献,所及记录一下其对应关系,最后跑一边答案就出来了

    好像说的有点绕,不过确实是尽我所能去描述清楚了。。可能也是我逻辑太混乱了吧,菜是原罪

    代码:

    #include<iostream>
    #include<cstdlib>
    #include<string>
    #include<cstring>
    #include<cstdio>
    #include<algorithm>
    #include<climits>
    #include<cmath>
    #include<cctype>
    #include<stack>
    #include<queue>
    #include<list>
    #include<vector>
    #include<set>
    #include<map>
    #include<sstream>
    #include<unordered_map>
    using namespace std;
        
    typedef long long LL;
        
    const int inf=0x3f3f3f3f;
    
    const int N=1e5+100;
    
    const int M=3e5+100;
     
    struct Edge
    {
    	int to,w,next;
    }edge[M];//边数
    
    unordered_map<int,bool>mp;
     
    int head[N],cnt,nx[N];
    
    bool vis[N];
     
    void addedge(int u,int v,int w)
    {
    	edge[cnt].to=v;
    	edge[cnt].w=w;
    	edge[cnt].next=head[u];
    	head[u]=cnt++;
    	edge[cnt].to=u;
    	edge[cnt].w=0;//反向边边权设置为0
    	edge[cnt].next=head[v];
    	head[v]=cnt++;
    }
     
    int d[N],now[N];//深度 当前弧优化
     
    bool bfs(int s,int t)//寻找增广路
    {
    	memset(d,0,sizeof(d));
    	queue<int>q;
    	q.push(s);
    	now[s]=head[s];
    	d[s]=1;
    	while(!q.empty())
    	{
    		int u=q.front();
    		q.pop();
    		for(int i=head[u];i!=-1;i=edge[i].next)
    		{
    			int v=edge[i].to;
    			int w=edge[i].w;
    			if(d[v])
    				continue;
    			if(!w)
    				continue;
    			d[v]=d[u]+1;
    			now[v]=head[v];
    			q.push(v);
    			if(v==t)
    				return true;
    		}
    	}
    	return false;
    }
     
    int dinic(int x,int t,int flow)//更新答案
    {
    	if(x==t)
    		return flow;
    	int rest=flow,i;
    	for(i=now[x];i!=-1&&rest;i=edge[i].next)
    	{
    		int v=edge[i].to;
    		int w=edge[i].w;
    		if(w&&d[v]==d[x]+1)
    		{
    			int k=dinic(v,t,min(rest,w));
    			if(!k)
    				d[v]=0;
    			edge[i].w-=k;
    			edge[i^1].w+=k;
    			rest-=k;
    		}
    	}
    	now[x]=i;
    	return flow-rest;
    }
     
    void init()
    {
    	for(int i=1;i<=5000;i++)//预处理平方数
    		mp[i*i]=true;
    	memset(head,-1,sizeof(head));
    	memset(nx,-1,sizeof(nx));//数组模拟链表
    	memset(vis,false,sizeof(vis));
    	cnt=0;
    }
     
    int solve(int st,int ed)
    {
    	int ans=0,flow;
    	while(bfs(st,ed))
    		while(flow=dinic(st,ed,inf))
    			ans+=flow;
    	return ans;
    }
    
    int main()
    {
    //  freopen("input.txt","r",stdin);
    //  ios::sync_with_stdio(false);
    	init();
    	int n,st=N-1,ed=st-1;
    	scanf("%d",&n);
    	int num=0,flow=0;
    	while(num-flow<=n)
    	{
    		num++;
    		addedge(st,num<<1,1);
    		addedge(num<<1|1,ed,1);
    		for(int i=1;i<num;i++)
    			if(mp[i+num])
    				addedge(i<<1,num<<1|1,1);
    		flow+=solve(st,ed);
    	}
    	num--;
    	for(int i=1;i<=num;i++)
    	{
    		int u=i<<1;
    		for(int j=head[u];j!=-1;j=edge[j].next)
    		{
    			int v=edge[j].to;
    			int w=edge[j].w;
    			if(v==st)
    				continue;
    			if(w==0)
    				nx[i]=(v-1)/2;
    		}
    	}
    	printf("%d\n",num);
    	for(int i=1;i<=num;i++)
    	{
    		if(!vis[i])
    		{
    			int k=i;
    			while(k!=-1)
    			{
    				vis[k]=true;
    				printf("%d ",k);
    				k=nx[k];
    			}
    			printf("\n");
    		}
    	}
    	
    	
    	
    	
    	
    	
    
            
            
            
             
            
        return 0;
    }

     

    展开全文
  • JAVA自学

    2012-09-21 20:39:46
    到了庐山,脉络形状扔在一边,盯着棵棵小草、粒粒石子的看,怎么样才能识得“真面目”? 作为应用型的人才,是研究回字的n种写法还是抓紧时间向着主要应用的方向努力,请自己作出抉择。 以项目驱动自己的...
  • react-native 布局篇

    2021-01-10 04:06:31
    都会百分之百的占满父容器。 水平垂直居中 <p>css 里边经常会做的事情是去讲个文本或者图片水平垂直居中,如果使用过css 的flexbox当然知道使用<code>alignItems</code> 和 <code>justifyContent</code> . ...
  • 次偶然的编剧集电视剧夏天上改变了自命运环球顶樑,三人在创车祸中不知被记忆差网识到创作,并被问流言败,以及行业服务所有的低调教同才力,陈昭和唐诗诗妍展开了段截然不同的“2014年间段感情”,两人...
  • 并不代表上来就要写100%场景覆盖的测试用例。个人一直坚持个观点:基于投入产出比来做测试。由于维护测试用例也是大笔开销(毕竟没有多少测试会专门帮前端写业务测试用例,而前端使用的...
  • 1.cf [Fillomino 2]题目大意:给出个数字n 代表n*n的棋盘,给出n 个数,代表从 (1,1)~(n,n)棋盘上的数字,让你在棋盘主对角线下方的棋盘填数字,满足以下条件:对于 主对角的任意数字x,和他联通的(包括他...

    昨天打了天梯,忘了发总结。
    天梯总结:对于团队整体还算可以,拿了省铜。对于个人,怎么说呢,有点可惜吧,前面有道字符串的题忘了读掉回车,调了好久耽误了些时间,结果导致后面的题来不及看,最后离个人的铜奖几分之差,说到底还是太菜了,继续努力!!

    1.cf [Fillomino 2]题目大意:给出一个数字n 代表n*n的棋盘,给出n 个数,代表从 (1,1)~(n,n)棋盘上的数字,让你在棋盘主对角线下方的棋盘填数字,满足以下条件:对于 主对角的任意数字x,和他联通的(包括他自己共x个单元格)标记为x,最后输出棋盘,对角线上方和下方重复了,只需要看下方即可。

    (思路:之前做过类似思路的题:找到特殊的,操作之后其他的某个又可以变成特殊的。首先想到1周围是不用填数的,因此所有在1上方的(y,y)可以在(y+1,y)先填一个,所有在1下方的(y,y)可以在 (y-1,y)先填一个,这样只是把1的包围了,其他的都减1,这样又会出现1,重复操作。)

    总结:找到特殊的,看对特殊的操作之后,其他的是不是又有变成特殊的。

    2.acwing 185. 玛雅游戏 类似于俄罗斯方块 当行或列颜色一样的方块大于等于3时可以消除(行和列可以共用)给定步数n问是否能恰好n步消除所有方块(每次操作只能左右移动方块),并输出操作方案,如果有多组方案,输出(x,y,d)(向右移动记为1,1优先于 -1)字典序最小的。

    首先明确搜索顺序,很明显按行从小到大,列从小到达,按向右向左搜呗,但明显会超时,所以接下来要进行剪枝:首先想想移动的本质是什么? 对!!交换,既然交换,那自然想到有重复的操作,即在x位置时右移和x+1位置时左移,所以第一个剪枝就出来了。

    剪枝1:当左边没有方块是,才进行左移操作

    剪枝2 当某种颜色的方块只剩下1个或者2个时,肯定消除不完,直接回溯。

    另外就是要回溯,所以操作之前备份一下。

    重难点是移动以及移动后方格的更新,因为不一定消除一次,引发连锁反应,所以用while循环,纪录棋盘要不要发生变化,如果不发生变化了,退出循环。

    展开全文
  • 这个很好理解,也就是说,个比方,把它看作简单的除法,计算上位时的余数乘以2后,如果比较大可以当被除数,就再去除除数求余。有一点和普通除法不同的是,因为多项式除法中采用不带借位的减法运算,所以0x10000...
  • 出n(\(\le 200\))个盒子,第i个盒子长\(x_i\),宽\(y_i\),个盒子可以放入长宽都大于等于它的盒子里,并且每个盒子里只能放入个盒子(可以嵌套),嵌套的盒子的占地面积等于最外层的盒子的占地面积,求最小的占...

    题目大意:

    给出n(\(\le 200\))个盒子,第i个盒子长\(x_i\),宽\(y_i\),一个盒子可以放入长宽都大于等于它的盒子里,并且每个盒子里只能放入一个盒子(可以嵌套),嵌套的盒子的占地面积等于最外层的盒子的占地面积,求最小的占地面积之和。

    题目分析:

    直接打了贪心,得了50分。用脑子想想就知道第3题怎么可能这么简单,果真。
    本题的本质就是能不能给一个盒子找一个长宽都大于等于它的匹配。

    • 匈牙利+贪心:如果a可以包含b,则连一条边a<-b,然后按照面积从大到小跑匈牙利,如果能够找到一个匹配,就把这个盒子的面积减掉。
    • 费用流: 将一个盒子拆成两个点1~n, n+1~2n, 如果a可以包含b,就连一条a->b+n,流量为1(只能用1个),费用为\(S_b\)的边,最后从s向1~n连流量为1,费用为0的边,从n+1~2n向t连流量为1,费用为0的边,跑最大费用最大流,将费用从总面积中减去。(费用流要去重)

    code

    匈牙利

    #include<bits/stdc++.h>
    using namespace std;
    
    namespace IO{
        inline int read(){
            int i = 0, f = 1; char ch = getchar();
            for(; (ch < '0' || ch > '9') && ch != '-'; ch = getchar());
            if(ch == '-') f = -1, ch = getchar();
            for(; ch >= '0' && ch <= '9'; ch = getchar()) i = (i << 3) + (i << 1) + (ch - '0');
            return i * f;
        }
        inline void wr(int x){
            if(x < 0) putchar('-'), x = -x;
            if(x > 9) wr(x / 10);
            putchar(x % 10 + '0');
        }
    }using namespace IO;
    
    const int N = 1000;
    int n;
    struct node{
        int x, y;
        inline bool operator < (const node &b) const{
            return x*y < b.x*b.y;
        }
    }box[N];
    bool vst[N << 2];
    int mateR[N << 2], ecnt, adj[N << 2], nxt[N << 2], go[N << 2], ans, to[N][N];
    
    inline bool hungry(int u){
        for(int i = n; i > u; i--){
            if(!to[u][i]) continue;
            if(vst[i]) continue;
            vst[i] = true;
            if(!mateR[i] || hungry(mateR[i])){
                mateR[i] = u;
                return true;
            }
        }
        return false;
    }
    
    inline void addEdge(int u, int v){
        nxt[++ecnt] = adj[u], adj[u] = ecnt, go[ecnt] = v;
    }
    
    int main(){
        n = read();
        for(int i = 1; i <= n; i++){
            int x = read(), y = read();
            box[i] = (node){x, y};
        }
        sort(box + 1, box + n + 1);
        for(int i = 1; i <= n; i++){
            ans += box[i].x * box[i].y;
            for(int j = i + 1; j <= n; j++){
                if(box[i].x <= box[j].x && box[i].y <= box[j].y)
                    to[i][j] = 1;
            }
        }
        for(int i = n - 1; i >= 1; i--){
            if(hungry(i)) ans -= box[i].x * box[i].y;
            memset(vst, 0, sizeof vst);
        }
        wr(ans);
        return 0;
    }

    费用流

    #include<bits/stdc++.h>
    using namespace std;
    
    namespace IO{
        inline int read(){
            int i = 0, f = 1; char ch = getchar();
            for(; (ch < '0' || ch > '9') && ch != '-'; ch = getchar());
            if(ch == '-') f = -1, ch = getchar();
            for(; ch >= '0' && ch <= '9'; ch = getchar()) i = (i << 3) + (i << 1) + (ch - '0');
            return i * f;
        }
        inline void wr(int x){
            if(x < 0) putchar('-'), x = -x;
            if(x > 9) wr(x / 10);
            putchar(x % 10 + '0');
        }
    }using namespace IO;
    
    const int N = 205, OO = 0x3f3f3f3f;
    int n, ecnt = 1, adj[N << 2], nxt[100050], go[100050], cap[100050], len[100050];
    int src, des, dis[N << 2], cur[N << 2], sum;
    struct node{
        int x, y;
        inline bool operator < (const node &b) const{
            return x < b.x || (x == b.x && y < b.y);
        }
    }box[N], unik[N];
    
    inline void addEdge(int u, int v, int c, int cost){
        nxt[++ecnt] = adj[u], adj[u] = ecnt, go[ecnt] = v, cap[ecnt] = c, len[ecnt] = cost;
        nxt[++ecnt] = adj[v], adj[v] = ecnt, go[ecnt] = u, cap[ecnt] = 0, len[ecnt] = -cost;
    }
    
    int vt = 0;
    inline bool SPFA(){
        static queue<int> que;
        static int vst[N << 2];
        memset(vst, 0, sizeof vst);
        while(!que.empty()) que.pop();
        que.push(src);
        for(int i = src; i <= des; i++) cur[i] = adj[i], dis[i] = -OO;
        dis[src] = 0;
        while(!que.empty()){
            int u = que.front(); que.pop(); vst[u] = 0;
            for(int e = adj[u]; e; e = nxt[e]){
                int v = go[e];
                if(dis[v] < dis[u] + len[e] && cap[e]){
                    dis[v] = dis[u] + len[e];
                    if(!vst[v]) vst[v] = 1, que.push(v);
                }
            }
        }
        return dis[des] !=  -OO;
    }
    
    bool walk[N << 2];
    inline int dinic(int u, int flow, int &ans){
        if(u == des){
            ans += flow * dis[u];
            return flow;
        }
        int delta, ret = 0;
        walk[u]=1;
        for(int &e = cur[u]; e; e = nxt[e]){
            int v = go[e];
            if(!walk[v] && dis[v] == dis[u] + len[e] && cap[e]){
                delta = dinic(v, min(cap[e], flow - ret), ans);
                if(delta){
                    ret += delta, cap[e] -= delta, cap[e ^ 1] += delta;
                    if(flow == ret) break;
                }
            }
        }
        if(flow != ret) dis[u] = -OO;
        return ret;
    }
    
    int lenn;
    inline void uni(){
        lenn = 0;
        sort(box+1,box+n+1);
        for(int i = 1; i <= n; i++){
            if(box[i].x != box[i - 1].x || box[i].y != box[i - 1].y)
                unik[++lenn].x = box[i].x, unik[lenn].y = box[i].y;
        }
    }
    int main(){
        n = read(); src = 0, des = 2 * n + 1;
        for(int i = 1; i <= n; i++) box[i].x = read(), box[i].y = read();
        uni();
        for(int i = 1; i <= lenn; i++){
            sum += unik[i].x * unik[i].y;
            for(int j = 1; j <= lenn; j++){
                if(i == j) continue;
                if(unik[j].x >= unik[i].x && unik[j].y >= unik[i].y) 
                    addEdge(i, j + n, 1, unik[i].x*unik[i].y);
            }
        }
        for(int i = 1; i <= n; i++) addEdge(src, i, 1, 0), addEdge(i + n, des, 1, 0);
        while(SPFA()){
            int ret = 0;
            memset(walk, 0, sizeof walk);
            dinic(src, OO, ret);
            sum -= ret;
        }
        wr(sum), putchar('\n');
        return 0;
    }

    转载于:https://www.cnblogs.com/CzYoL/p/7694086.html

    展开全文
  • 这题比赛的时候只想到了质数怎么分配的,没有想到边的贡献怎么算,后来看了大佬的blog才知道的,Orz,其实你把个树找个顶点dfs遍,设size[i]为该结点子树的大小,那么该点与其父亲结点的边的贡献为size[i]⋅(n...
  • 个大表每行下面需要加行空行,怎么加最方便 Excel中插入空白行 快速删除工作表中的空行快速删除空行次删完Excel里面多很多的空白行 每30行为页并加上个标题如何实现如何实现隔行都加上标题项 如何把...
  • EXCEL函数公式集

    热门讨论 2010-03-16 03:26:38
    个大表每行下面需要加行空行,怎么加最方便 Excel中插入空白行 快速删除工作表中的空行快速删除空行次删完Excel里面多很多的空白行 每30行为页并加上个标题如何实现如何实现隔行都加上标题项 如何把...
  • 面试那天,刚好来了m*n个MM,站成一个m*n的队列,副导演Fe(OH)2为每个MM了分数,分数都是32位有符号整数。 开始我很纳闷:分数怎么还有负的?Fe(OH)2解释说,根据选拔规则,头发染成黄色、化妆太浓、穿的太少...
  • 面试那天,刚好来了m*n个MM,站成一个m*n的队列,副导演Fe(OH)2为每个MM了分数,分数都是32位有符号整数。 开始我很纳闷:分数怎么还有负的?Fe(OH)2解释说,根据选拔规则,头发染成黄色、化妆太浓、穿的太少...
  • 面试那天,刚好来了m*n个MM,站成一个m*n的队列,副导演Fe(OH)2为每个MM了分数,分数都是32位有符号整数。 开始我很纳闷:分数怎么还有负的?Fe(OH)2解释说,根据选拔规则,头发染成黄色、化妆太浓、穿的太少...
  • 4.5.4 怎么打出线程栈信息。 开源框架 4.5.5 简单讲讲tomcat结构,以及其类加载器流程,线程模型等。 4.5.6 tomcat如何调优,涉及哪些参数 。 4.5.7 讲讲Spring加载流程。 4.5.8 Spring AOP的实现原理。 4.5.9...
  • 你必须知道的495个C语言问题

    千次下载 热门讨论 2015-05-08 11:09:25
    1.28 文件中的第个声明就报奇怪的语法错误,可我看没什么问题。这是为什么? 1.29 为什么我的编译器不允许我定义大数组,如doublearray[256][256]? 命名空间 1.30如何判断哪些标识符可以使用,哪些被保留了...
  • 面试那天,刚好来了m*n个MM,站成一个m*n的队列,副导演Fe(OH)2为每个MM了分数,分数都是32位有符号整数。 开始我很纳闷:分数怎么还有负的?Fe(OH)2解释说,根据选拔规则,头发染成黄色、化妆太浓、穿的太少...
  • 例如定义个包含N个指向返回指向字符的指针的函数的指针的数组? 11  1.22 如何声明返回指向同类型函数的指针的函数?我在设计个状态机,用函数表示每种状态,每个函数都会返回个指向下个状态的函数的指针...
  • hundred hund【百,h房子-户,n连接,d土地→百户家庭连接起来的土地,就是个郡县 《英国将100户人家划分为个郡县》】,red【红色:r火,d=t树木→点起木材,烧起来的火的颜色】→老师给你上100的红圈圈 ...
  • 《你必须知道的495个C语言问题》

    热门讨论 2010-03-20 16:41:18
    1.28 文件中的第个声明就报奇怪的语法错误,可我看没什么问题。这是为什么? 15 1.29 为什么我的编译器不允许我定义大数组,如double array[256][256]? 15 命名空间 15 1.30 如何判断哪些标识符可以使用,...
  • 最新Java面试宝典pdf版

    热门讨论 2011-08-31 11:29:22
    8.用条SQL语句 查询每门课都大于80的学生姓名 100 9.所有部门之间的比赛组合 100 10.每个月份的发生额都比101科目多的科目 101 11.统计每年每月的信息 102 12.显示文章标题,发帖人、最后回复时间 103 13.删除...
  • Java面试宝典-经典

    2015-03-28 21:44:36
    8.用条SQL语句 查询每门课都大于80的学生姓名 100 9.所有部门之间的比赛组合 100 10.每个月份的发生额都比101科目多的科目 101 11.统计每年每月的信息 102 12.显示文章标题,发帖人、最后回复时间 103 13.删除...
  • Java面试宝典2010版

    2011-06-27 09:48:27
    8.用条SQL语句 查询每门课都大于80的学生姓名 9.所有部门之间的比赛组合 10.每个月份的发生额都比101科目多的科目 11.统计每年每月的信息 12.显示文章标题,发帖人、最后回复时间 13.删除除了id号不同,...
  • 8.用条SQL语句 查询每门课都大于80的学生姓名 100 9.所有部门之间的比赛组合 100 10.每个月份的发生额都比101科目多的科目 101 11.统计每年每月的信息 102 12.显示文章标题,发帖人、最后回复时间 103 13.删除...
  • Java面试宝典2012版

    2012-12-03 21:57:42
    8.用条SQL语句 查询每门课都大于80的学生姓名 100 9.所有部门之间的比赛组合 100 10.每个月份的发生额都比101科目多的科目 101 11.统计每年每月的信息 102 12.显示文章标题,发帖人、最后回复时间 103 13...

空空如也

空空如也

1 2 3 4
收藏数 78
精华内容 31
关键字:

怎么打出n分之一