精华内容
下载资源
问答
  • 减少辐射干扰—极化隔离

    千次阅读 2018-05-10 18:52:02
    看到这个第一反应懵逼,什么意思,慢慢的查了一下才明白。一、定义极化隔离:干扰源与干扰对象在布局上采取极化隔离措施。即一个为垂直极化时,另一个为水平极化,以减小其间的耦合。 通信中为减少收发系统的隔离...

    看到这个第一反应是懵逼,什么意思,慢慢的查了一下才明白。

    一、定义

    极化隔离:干扰源与干扰对象在布局上采取极化隔离措施。即一个为垂直极化时,另一个为水平极化,以减小其间的耦合。

    通信中为减少收发系统的隔离,除了收发的频率间隔法,还可以采用极化隔离的方法,即发射的天线极化与接收的天线极化相反,如接收使用的线性垂直极化,则发射就采用线性水平极化,通过极化隔离可实现大于35dB隔离。

    二、解释

    1、天线极化

    天线极化是描述天线辐射电磁波矢量空间指向的参数。由于电场与磁场有恒定的关系,故一般都以电场矢量的空间指向作为天线辐射电磁波的极化方向。天线的极化特性是以天线辐射的电磁波在最大辐射方向上电场强度矢量的空间取向来定义的,是描述天线辐射电磁波矢量空间指向的参数。由于电场与磁场有恒定的关系,故一般都以电场矢量的空间指向作为天线辐射电磁波的极化方向。

    2、极化分类

    天线的极化分为线极化、圆极化和椭圆极化。线极化又分为水平极化和垂直极化;圆极化又分为左旋圆极化和右旋圆极化。

    3、线极化

    (1)线极化描述

    电场矢量在空间的取向固定不变的电磁波叫线极化。有时以地面为参数,电场矢量方向与地面平行的叫水平极化,与地面垂直的叫垂直极化。电场矢量与传播方向构成的平面叫极化平面。垂直极化波的极化平面与地面垂直;水平极化波的极化平面则垂直于入射线、反射线和入射点地面的法线构成的入射平面。

    (2)线极化的数学分析

    在三维空间,沿Z轴方向传播的电磁波,其瞬时电场可写为:


    可见合成矢量的端点的轨迹为一条直线。线极化波又有水平极化波和垂直极化波之分。



    展开全文
  • 【大事小,小事无】 是什么意思(来源:辞典修订版) 缩小或消除冲突。《文明小史.第一回》:「他见我们地方官以礼相待,就是有点需索便也不好十分需索,能够大事小,小事无。」也作「大事小,小事了...

    【大事化小,小事化无】 是什么意思(来源:辞典修订版)

    • 缩小或消除冲突。《文明小史.第一回》:「他见我们地方官以礼相待,就是有点需索便也不好十分需索,能够大事化小,小事化无。」也作「大事化小,小事化了。」、「大事化为小事,小事化为无事。」

    【大事化小,小事化无】 是什么意思(来源:辞典简编版)

    • 将冲突或影响逐渐缩小到最低的程度。
        【造句】他调停的手腕极佳,常能把大事化小,小事化无。
    展开全文
  • 化极大:回溯+剪枝 先来说大算法主要应用于什么样的游戏: 1. 零和游戏(Zero-sum Game):意思就是你死我活,一方的胜利代表另一方的失败,比如,象棋,五子棋等。 2. 完全信息(Perfect Information)...

    极小化极大:回溯+剪枝

    先来说极小极大算法主要应用于什么样的游戏:
    1. 零和游戏(Zero-sum Game):意思就是你死我活,一方的胜利代表另一方的失败,比如,象棋,五子棋等。
    2. 完全信息(Perfect Information):玩家知道之前所有的步骤。象棋就是完全信息,因为玩家是交替着落子,且之前的步骤都能在棋盘上体现,但是石头剪子布就不是。

     

    极大极小算法有些不明白 ? - 还想养只小短腿的回答 - 知乎 https://www.zhihu.com/question/27221568/answer/140874499

     

     

    你和你的朋友,两个人一起玩 Nim 游戏:桌子上有一堆石头,每次你们轮流拿掉 1 - 3 块石头。 拿掉最后一块石头的人就是获胜者。你作为先手。

    你们是聪明人,每一步都是最优解。 编写一个函数,来判断你是否可以在给定石头数量的情况下赢得游戏。

    示例:

    输入: 4
    输出: false 
    解释: 如果堆中有 4 块石头,那么你永远不会赢得比赛;
         因为无论你拿走 1 块、2 块 还是 3 块石头,最后一块石头总是会被你的朋友拿走。

    class Solution {
    public:
        bool canWinNim(int n) {
            return n%4!=0;
        }
    };

    bitset容器

    可以下标访问,b[0]
    类似数组的结构
    它的每一个元素只能是0或1
    每个元素仅用1bit空间
    运用各种位运算,与或异或非,移位
    bitset<bitNums> b1;bitNums位数据,默认补0
    bitset<bitNums> b2("100101"),b3(99)
    b.count();//1的个数
    b.size();
    b.test(index);//true:index位置为1 否则0
    b.any();//true:存在1
    b.all();//true:都为1
    b.none();//true:没有1==都是0
    b.flip(index);//对应位置取反,默认全取反
    b.set(index);//对应位置置1,默认全置1
    b.set(index,boolx);//对应位置boolx
    b.reset(index);//对应位置0,默认全置0
    b.to_string();//转sring
    b.to_ulong();//转unsigned long
    b.to_ullong();

    在 "100 game" 这个游戏中,两名玩家轮流选择从 1 到 10 的任意整数,累计整数和,先使得累计整数和达到 100 的玩家,即为胜者。

    如果我们将游戏规则改为 “玩家不能重复使用整数” 呢?

    例如,两个玩家可以轮流从公共整数池中抽取从 1 到 15 的整数(不放回),直到累计整数和 >= 100。

    给定一个整数 maxChoosableInteger (整数池中可选择的最大数)和另一个整数 desiredTotal(累计和),判断先出手的玩家是否能稳赢(假设两位玩家游戏时都表现最佳)?

    你可以假设 maxChoosableInteger 不会大于 20, desiredTotal 不会大于 300。

    示例:

    输入:
    maxChoosableInteger = 10
    desiredTotal = 11

    输出:
    false

    解释:
    无论第一个玩家选择哪个整数,他都会失败。
    第一个玩家可以选择从 1 到 10 的整数。
    如果第一个玩家选择 1,那么第二个玩家只能选择从 2 到 10 的整数。
    第二个玩家可以通过选择整数 10(那么累积和为 11 >= desiredTotal),从而取得胜利.
    同样地,第一个玩家选择任意其他整数,第二个玩家都会赢。

    class Solution {//极小化极大:超时
        vector<bool> visited;
    public:
        bool canIWin(int maxChoosableInteger, int desiredTotal) {
            if(desiredTotal<=1)return true;
            //if(((1+maxChoosableInteger)*maxChoosableInteger>>1)<desiredTotal)return false;
            visited.resize(maxChoosableInteger+1,false);
            return alphaBeta(true,desiredTotal,0,1);
        }
        int alphaBeta(bool player, int target,int alpha,int beta){
            if(target<=0){
                if(player)return 0;
                else return 1;
            }
            if(player){            
                for(int i=1;i<=visited.size();++i){
                    if(!visited[i]){
                        visited[i]=true;
                        int temp=alphaBeta(!player,target-i,alpha,beta);
                        visited[i]=false;
                        if(temp>alpha){
                            alpha=temp;                        
                        }
                        if(alpha>=beta)
                            return alpha;                    
                    }
                }
                return alpha;
            }
            else{
                 for(int i=1;i<=visited.size();++i){
                    if(!visited[i]){
                        visited[i]=true;
                        int temp=alphaBeta(!player,target-i,alpha,beta);
                        visited[i]=false;
                        if(temp<beta){
                            beta=temp;                        
                        }
                        if(alpha>=beta)
                            return beta;                    
                    }
                }
                return beta;
            }
            
        }
    };

     

    //极小化极大,改进:bitset+合并player(1表示先手,0表示后手)+map
    //返回值1表示先手能赢,0表示先手输
    //player1时,存在一个返回值为true则true,否则false        或运算
    //player0时,全部都返回true才true,否则false(存在一个返回值为false)    与运算
    class Solution {
        std::unordered_map<unsigned long, bool> mp;
        std::bitset<25> bs;
        int maxN;
    public:
        bool canIWin(int maxChoosableInteger, int desiredTotal) {
            if(desiredTotal<=1)return true;
            if(((1+maxChoosableInteger)*maxChoosableInteger>>1)<desiredTotal)return false;
            maxN=maxChoosableInteger;
            return alphaBeta(1,desiredTotal);
        }
        int alphaBeta(bool player, int target){
            if(target<=0)
                return !player;
            unsigned long bsMap=bs.to_ulong();
            if (mp.count(bsMap)) 
                return mp[bsMap]; 
            for(int i=1;i<=maxN;++i){
                if(bs[i])continue;
                bs[i]=true;
                if(player==alphaBeta(!player,target-i)){
                    bs[i]=false; 
                    return mp[bsMap] = player;
                }
                bs[i]=false;             
            }
            return mp[bsMap] = !player;
        }
    };
    class Solution {//评论区答案
    public:
        int maxChoosableInteger, desiredTotal;
        std::unordered_map<unsigned long long, bool> mp;
        std::bitset<25> bs;
        // 当前这个状态下, 能否稳赢. total_sum记录当前的和, bitset记录那些数已经被选择过了
        bool dfs(int total_sum) {
            // 递归的边界
            if (total_sum >= desiredTotal) return true;
            // 记忆化
            if (mp.find(bs.to_ullong()) != mp.end()) return mp[bs.to_ullong()];    
            
            // 假设当前状态是A
            // 这里就是上文说的, 枚举B走的所以情况的(用一个for), 只有循环里B都不能稳赢, A才能稳赢. 
            for (int i = 1; i <= maxChoosableInteger; ++i) {
                if (bs[i]) continue;            
                bs[i] = 1;
                // 这里就是枚举B 
                if (dfs(total_sum + i)) {
                    bs[i] = 0;
                    return mp[bs.to_ullong()] = false;
                }
                bs[i] = 0;
            }
            return mp[bs.to_ullong()] = true;
        }
    
        bool canIWin(int a_, int b_) {
            maxChoosableInteger = a_;
            desiredTotal = b_;
            if(b_<=1)return true;
            // 所有数加起来都小于desiredTotal, 则稳输
            if ((maxChoosableInteger + 1) * maxChoosableInteger * 0.5 < desiredTotal)
                return false;
            for (int i = 1; i <= maxChoosableInteger; ++i) {
                bs[i] = 1;
                if (dfs(i)) return true;
                bs[i] = 0;
            }
            return false;
        }
    };

    给定一个表示分数的非负整数数组。 玩家1从数组任意一端拿取一个分数,随后玩家2继续从剩余数组任意一端拿取分数,然后玩家1拿,……。每次一个玩家只能拿取一个分数,分数被拿取之后不再可取。直到没有剩余分数可取时游戏结束。最终获得分数总和最多的玩家获胜。

    给定一个表示分数的数组,预测玩家1是否会成为赢家。你可以假设每个玩家的玩法都会使他的分数最大化。

    示例 1:

    输入: [1, 5, 2]
    输出: False
    解释: 一开始,玩家1可以从1和2中进行选择。
    如果他选择2(或者1),那么玩家2可以从1(或者2)和5中进行选择。如果玩家2选择了5,那么玩家1则只剩下1(或者2)可选。
    所以,玩家1的最终分数为 1 + 2 = 3,而玩家2为 5。
    因此,玩家1永远不会成为赢家,返回 False。


    示例 2:

    输入: [1, 5, 233, 7]
    输出: True
    解释: 玩家1一开始选择1。然后玩家2必须从5和7中进行选择。无论玩家2选择了哪个,玩家1都可以选择233。
    最终,玩家1(234分)比玩家2(12分)获得更多的分数,所以返回 True,表示玩家1可以成为赢家。


    注意:


        1 <= 给定的数组长度 <= 20.
        数组里所有分数都为非负数且不会大于10000000。
        如果最终两个玩家的分数相等,那么玩家1仍为赢家。

    //最小化极大,没有记忆线索
    class Solution {   
        vector<int> nums;
    public:
        bool PredictTheWinner(vector<int>& nums) {
            if(nums.size()<=2)return true;
            this->nums=nums;
            return helper(1,0,nums.size()-1,0);
        }
        bool helper(bool player,int le,int ri,int sum){
            if(le>ri)
                return sum>=0;
            if(player)
                return helper(!player,le+1,ri,sum+nums[le])|helper(!player,le,ri-1,sum+nums[ri]);        
            else
                return helper(!player,le+1,ri,sum-nums[le])&helper(!player,le,ri-1,sum-nums[ri]);        
        }
    };
    //最小化极大,记忆话线索(bistset+map)
    class Solution {
        bitset<20> bs;
        vector<int> nums;
        unordered_map<unsigned long,int>mp;
    public:
        bool PredictTheWinner(vector<int>& nums) {
            if(nums.size()<=2)return true;
            this->nums=nums;
            return helper(1,0,nums.size()-1,0);//player1表示先手,0表示后手
        }
        bool helper(bool player,int le,int ri,int sum){//返回1表示先后玩家赢
            if(le>ri)
                return sum>=0;
            int bsMap=bs.to_ulong();
            if(mp.count(bsMap))return mp[bsMap];
            if(player){//存在一true即为true
                bs[le]=1;
                if(helper(!player,le+1,ri,sum+nums[le])){
                    bs[le]=0;
                    return bs[bsMap]=true;
                }
                bs[le]=0;
    
                bs[ri]=1;
                if(helper(!player,le,ri-1,sum+nums[ri])){
                    bs[ri]=0;
                    return bs[bsMap]=true;
                }
                bs[ri]=0;
    
                return bs[bsMap]=false;
            }
            else{//存在一false即false
                bs[le]=1;
                if(!helper(!player,le+1,ri,sum-nums[le])){
                    bs[le]=0;
                    return bs[bsMap]=false;
                }
                bs[le]=0;
    
                bs[ri]=1;
                if(!helper(!player,le,ri-1,sum-nums[ri])){
                    bs[ri]=0;
                    return bs[bsMap]=false;
                }
                bs[ri]=0;
    
                return bs[bsMap]=true;
            }
    
        }
    };
    //改用[le,ri]记忆化线索
    //但测试用例[1,2,99]报错,未发现原因
    class Solution {   
        vector<int> nums;
        vector<vector<int>>visited;
    public:
        bool PredictTheWinner(vector<int>& nums) {
            int nSize=nums.size();
            if(nSize<=2)return true;
            this->nums=nums;
            visited.resize(nSize,vector<int>(nSize,-1));
            return helper(1,0,nSize-1,0);
        }
        bool helper(bool player,int le,int ri,int sum){
            if(le>ri)
                return sum>=0;
            if(visited[le][ri]!=-1)return visited[le][ri];
            if(player){
                if(helper(!player,le+1,ri,sum+nums[le]))
                    return visited[le][ri]=true;
                if(helper(!player,le,ri-1,sum+nums[ri]))
                    return visited[le][ri]=true;
                return visited[le][ri]=false;
            }
            else{
                if(!helper(!player,le+1,ri,sum-nums[le]))
                    return visited[le][ri]=false;
                if(!helper(!player,le,ri-1,sum-nums[ri]))
                    return visited[le][ri]=false;
                return visited[le][ri]=true;
            }
    
        }
    };

     

    展开全文
  • 大似然估计是什么意思? 首先,根据字面上来看,大和估计都比较好理解,大即最大,估计即大约计算出来的样子。那么似然是什么意思呢?似然,即(likelihood),牛津词典的解释为可能性(同义词为probability...

    在机器学习算法中,你能经常看到极大似然估计这个词语。比如在对逻辑回归求解全局最小值的时候就需要用上极大似然估计。极大似然估计是机器学习算法中必须掌握的一个知识点。

    极大似然估计是什么意思?

    首先,根据字面上来看,极大和估计都比较好理解,极大即最大化,估计即大约计算出来的样子。那么似然是什么意思呢?似然,即(likelihood),牛津词典的解释为可能性(同义词为probability)。所以极大似然估计的字面意思就是最大可能性的情况就是我们需要大约计算出来的样子。

    举个例子来说:

    有一个箱子,里面总共有100个形状相同但是有两种颜色,分别为黑色和白色的球。其中一种颜色是99个,另一种颜色是1个。现从箱里任取一球,颜色为黑色。那么,我们通过极大似然估计会认为箱子里极有可能黑色球99个。

    若实验中有n个可能结果,A1,A2……An,现做了一次试验,若事件Ai发生了,则认为事件Ai在这n个可能结果中出现的概率最大。

    总的来说,极大似然估计是建立在这样的思想上:已知某个参数能使这个样本出现的概率最大,我们当然不会再去选择其他小概率的样本,所以干脆就把这个参数作为估计的真实值。

    极大似然估计的表现形式

    1.若总体X为离散型,其概率分布为P{X=x}=p(x;Θ);其中Θ是未知参数。设(X1,X2,……Xn)是取自总体的样本容量为n的样本,则(X1,X2,……Xn)的联合分布律为。又设(X1,X2,……Xn)的一组观测值为(x1,x2……xn),易知样本X1,X2,……Xn取到的观测值x1,x2……xn的概率为

    这一概率随Θ的取值而变化,它是Θ的函数,称L(Θ)为样本的似然函数。

    2.若总体X为连续型,其概率密度函数为f(x;Θ), 其中Θ是未知参数。设(X1,X2,……Xn)是取自总体的样本容量为n的样本,则(X1,X2,……Xn)的联合概率密度为为。又设(X1,X2,……Xn)的一组观测值为(x1,x2……xn),易知样本X1,X2,……Xn取到的观测值x1,x2……xn的概率为

    同样,L(Θ)为样本的似然函数。

    极大似然估计法原理就是固定样本观测值(x1,x2……xn),挑选参数Θ使得

    这样得到的与样本值有关,称为参数Θ的极大似然估计值,其相应的统计量称为Θ的极大似然估计量。极大似然估计简记为MLE或

    极大似然估计求解

    那么要如何把参数Θ的极大似然估计值求出来呢。一般情况下:

    1. 构造似然函数L(Θ)
    2. 取对数ln L(Θ)
    3. 求解
    展开全文
  • 什么是NoSQL数据库?

    2014-07-21 23:24:20
    NoSQL数据库是什么 NoSQL说起来简单,但实际上到底有多少种呢?我在提笔的时候,到NoSQL的官方网站上确认了一下,竟然已经有122种了。另外官方网站上也介绍了本书没有涉及到的图形数据库和对象数据库等各个类别。...
  • 这可以大地方便网络上的一些操作,但同时,因为涉及到安全问题,所以并不希望把类里面所有的东西都能存储(因为那样,别人可以通过序列知道类里面的内容),那么我们就可以用上transient这个关键字,它的意思是...
  • 设计test()方法,初始三个类后,执行各个对象中的get()方法1000000000次,在形如B b = new BB()的前提下,通过b.get()样式运行后时间消耗远远大于通过((BB)b).get()循环的时间消耗,其他几个类似,代码附下 ...
  • 空间复杂度是O(1)是什么意思 O(1)指额外空间相对于输入数据量来说是常数中位数百度百科 常见OJ评判结果对照表,作为ACMer你懂得! 什么是化极大算法? Minimax算法又名化极大算法,是一种找出失败的...
  • Docker基础

    2020-12-09 14:15:59
    Docker Docker是什么 官方的原话 ​ Docker 是一个开源的应用容器引擎,基于 Go 语言 并遵从 Apache2.0 协议开源。...​ 在第一次听见docker这个名称的时候,我真的不知道什么意思,在网上看了一些资料还是不懂doc
  • 国产java类cms v3.0.161109

    2019-11-09 05:05:05
    具体什么意思呢,可以举个栗子看一下tjpcms动态如何配置增删改查下载下来的tjpcms怎么用?下载下来的压缩包工程源码及数据库文件,将源码导入到MyEclipse中,数据库导入到Mysql中,再配置一下工程中数据链接,...
  • transient 关键字的用途

    2007-06-23 17:00:00
    序列化是什么意思?java有个特点就是序列化,简单地来说就是可以将这个类存储在物理空间(当然还是以文件的形式存在),那么当你从本地还原这个文件时,你可以将它转换为它本身。这可以大地方便网络上的一些操作,...
  • Jenkins用来自动构建任务的,也许你还不知道什么叫自动构建任务,它的意思是可以针对某个任务进行自动,比如你开发的某个软件,每次写完代码提交到github之后,你可以设置让Jenkins自动进行打包构建发布包或者...
  • 从一个项目想到的

    2018-10-29 12:56:06
    项目一个典型的政务项目,信息,用户都集中一个内网,且用户极其有限,涉及到一些系统...什么意思呢,就是各个功能模块都由专人来开发,这样来保证开发效率和人员流动带来的一些附属问题。人类发展到今天,很大...
  • EM算法理解与推导

    2019-03-12 17:28:38
    首先我们开门见山,EM算法到底什么的,EM算法在面对一个含有隐变量的概率模型,一种迭代算法,目标就是观测数据关于参数的对数似然函数。 这么说可能很难理解,我们来举一个例子吧,就拿抛硬币来说,...
  • Docker

    2020-12-17 15:56:08
    1.Docker是什么 官方的原话 ​Docker 是一个开源的应用容器引擎,基于 Go 语言 并遵从 Apache2.0 协议开源。Docker 可以让开发者打包他们的应用以及依赖包到一个轻量级、可移植的容器中,然后发布到任何流行的 Linux...
  • 简介: 随着容器技术的快速发展和广泛应用,毫无疑问云原生技术未来发展的必然趋势。作为国内最早布局容器技术的阿里云,无论在...容器的英语 Container,它的意思是集装箱。我们知道,经济全球的基础就是
  • 零开销是什么意思? 即使FastStreams支持多种流类型,该API的设计方式也允许在大多数情况下无需任何动态分派即可处理读取和写入操作。 特别是,从memoryInput读取或写入memoryOutput将具有与在openarray循环的循环...
  • 吐槽:难受,刚回实验室,就要做项目,关键自己的方向还没定,听老板的意思是什么博弈进化认知智能啥的。。在雁栖湖打了一年的NLP基础,难道要付诸东流了吗?难受了…… Neo4j 多库切换 因为Neo4j的import...
  • 早在一百年以前,医生就开始利用一些简单的设备来做诊断,如显微镜和听诊器,等等。...相关的标准规定隔离电压须在3kVDC/1s以上,但这到底是什么意思?要全盘认识这个指标的复杂程度,请让我们深入了解
  • 早在一百年以前,医生就开始利用一些简单的设备来做诊断,如显微镜和听诊器,等等。...相关的标准规定隔离电压须在3kVDC/1s以上,但这到底是什么意思?要全盘认识这个指标的复杂程度,请让我们深入了解
  • 目录 PPT讲稿 重点问题准备 天线毕设问题预测 1、应用场景 2、参数越低越好还是越高越好 ...3、回波损耗、S11、反射系数、驻波比 ...4、参数的选择的依据(原因),选择参数进行优化的原因,对天线有...10、主极化与...
  • 大家可能对关系型计算比较陌生,但是对结构查询语言(SQL)比较熟悉,SQL被广泛用于关系型数据的查询和处理,它能告诉数据引擎完成什么样的计算,而不是如何完成这些计算。离线的意思是数据一旦进入系统就不会被...
  • 具体什么意思呢,可以举个栗子看一下tjpcms动态如何配置增删改查 下载下来的tjpcms怎么用? 下载下来的压缩包工程源码及数据库文件,将源码导入到MyEclipse中,数据库导入到Mysql中,再配置一下工程中数据...
  • 敏捷开发-Scrum.pptx

    2020-05-12 13:26:50
     Scrum是什么意思?  Scrum敏捷方法一分钟扫盲  Scrum敏捷方法丨的工作产品  Scrum敏捷方法丨的觇色  猪不鸡的故亊 Scrum过程 读前预习内容  创建和维护产品待开収项(Product Backlog)  迭代计划会 ...
  • arcgis10.1正式版下载加完美破解

    千次下载 热门讨论 2012-08-14 19:20:54
    但是在10.1中,我们新添加了Key Numbering,它的意思是,我们会在小多边形上标注1,2,3,4等序号,然后在地图上对这些序号进行1-1对应。 9)动态图例 在10.1中图例会随你图幅内的要素的变化而变化。即当图幅中的...

空空如也

空空如也

1 2 3 4 5
收藏数 91
精华内容 36
关键字:

极化是什么意思