精华内容
下载资源
问答
  • \quad求图连通分量个数方法很多,这里主要讨论两种方法,一种是通过dfs、bfs等遍历手段求得,一种是并查集。 一、利用dfs求图连通分量 \quad算法流程: 初始化连通分量个数为ccount=0; 从图任一顶点开始进行dfs...

    \quad 求图连通分量个数方法很多,这里主要讨论两种方法,一种是通过dfs、bfs等遍历手段求得,一种是并查集。

    一、利用dfs求图连通分量

    \quad 算法流程:

    • 初始化连通分量个数为ccount=0;
    • 从图中任一顶点开始进行dfs,通过该顶点遍历到的所有顶点属于同一连通分量,这些遍历到的顶点做好标记,表示已经被访问。ccount+=1;
    • 从未访问过的顶点中取出一个顶点重复第二步,遍历完后ccount+=1;
    • 重复上述过程,直到所有顶点均被标记;
    • 输出ccount,ccount即为图连通分量个数。
      \quad 我们还可以通过一个变量id记录每个顶点具体属于某个连通分量。在具体实现中,我实现了三个方法——1、查询图中连通分量个数;2、查询任意两点是否连通,即是否属于同一个连通分量;3、具体打印出每个连通分量包含的顶点情况。
      \quad 首先,我们先建立一个图,用邻接表存放与每个顶点相邻的顶点。
    #include<bits/stdc++.h>
    using namespace std;
    
    class graph {
    public:
        vector<vector<int> > g;  // 图的领接表
        graph(int V, bool directed=false){
            this->V=V;  // 需传入图的顶点数
            this->directed = directed;  // 是否为有向图
            // g初始化为V个空的vector, 表示每一个g[i]都为空, 即没有任和边
            g = vector<vector<int> >(V, vector<int>());
        }
        ~graph(){};
        void addEdge(int v, int w);  // 顶点v与w有一条边
        int getV() { return V; }  // 取出顶点数
        int getE() { return E; }  // 取出边数
    
    private:
        int V = 0;  // 顶点数
        int E = 0;  // 边数
        bool directed;  // 是否为有向图
    
    };
    
    void graph::addEdge(int v, int w) {
        assert(v>=0 && v<V);
        assert(w>=0 && w<V);
        g[v].push_back(w);
        if(!directed) g[w].push_back(v);  // 若不是有向图则w与v也有一条边
        E++;
    }
    

    \quad 接下来具体实现求取图连通分量的类Component。

    class Component {
    private:
        graph &G;  // 图的引用
        bool *visited;  // 记录节点是否被访问
        int ccount;  // 连通分量个数
        int *id;  // 给每个顶点所属的连通分量标号
    
        void dfs(int v);  // 从顶点v开始进行dfs
    public:
        Component(graph &graph): G(graph)
        {
            visited = new bool[G.getV()];
            id = new int[G.getV()];
            ccount = 0;
            for (int i = 0; i < G.getV(); ++i) {
                visited[i] = false;
                id[i] = -1;
            }
    
            for (int i = 0; i < G.getV(); ++i) {
                if(!visited[i])
                {
                    dfs(i);
                    ccount++;
                }
            }
        }
    
        ~Component(){
            delete[] visited;
            delete[] id;
        }
    
        // 返回连通分量个数
        int count()
        {
            return ccount;
        }
    
        // 查询v和w是否连通
        bool isConnected(int v, int w)
        {
            return id[v]==id[w];
        }
    
        // 以文字形式显示图的连通分量具体情况
        void verbose()
        {
            for (int i = 1; i <= ccount; ++i) {
                cout << "Component " << i << " Vertex:";
                for (int j = 0; j < G.getV(); ++j) {
                    if(id[j] == i-1) cout << " " << j;
                }
                cout << endl;
            }
        }
    };
    
    void Component::dfs(int v) {
        visited[v] = true;
        id[v] = ccount;
        // 遍历图G的顶点v的领接表
        for (int i = 0; i < G.g[v].size(); ++i) {
            if(!visited[G.g[v][i]])
                dfs(G.g[v][i]);
        }
    }
    

    \quad 在主函数中建立一个6个顶点,4条边的图。
    在这里插入图片描述

    int main()
    {
        graph G(6, false); // 建立顶点个数为6的图
        G.addEdge(0, 1);
        G.addEdge(0, 2);
        G.addEdge(1, 2);
        G.addEdge(3, 4);
    
        Component component(G);
        cout << "连通分量个数:" << component.count() << endl;  // 打印连通分量个数
        cout << "1,2点是否连通:" << component.isConnected(1, 2) << endl;  // 判断两点是否连通
        cout << "1,3点是否连通:" <<component.isConnected(1, 3) << endl;
        component.verbose();  // 显示具体信息
        return 0;
    }
    

    \quad 运行结果如下:
    在这里插入图片描述

    二、并查集求连通分量个数

    \quad 并查集操作分为两个,并Union和查Find。Union可以将两个顶点合在一个集合里面,拥有相同的“祖先”。查可以获得当前顶点所在集合的“祖先”。若两个顶点a,b在一个集合里,则Find(a)=Find(b)。因为这个在刷一些oj上刷题时经常用到,这里就直接给出常见写法:

    //
    // Created by 程勇 on 2019/3/7.
    //
    
    /*
     * 并查集可用来求图连通分类和最小生成树
     */
    #include<bits/stdc++.h>
    using namespace std;
    
    const int maxn = 1e+6+10;
    int parent[maxn];
    
    int Find(int p)
    {
        while(p != parent[p])
        {
            p = parent[p];
        }
        return p;
    }
    
    void Union(int p, int q)
    {
        if(Find(p) != Find(q))
            parent[p] = q;
    }
    
    int main()
    {
        int n, m;  // 顶点数和边数
        cin >> n >> m;
        for (int i = 1; i <= n; ++i) {
            parent[i] = i;  // 初始化每个顶点指向自己
        }
        for (int j = 0; j < m; ++j) {
            int v, w;
            cin >> v >> w;  // 依次读入边
            v = Find(v);
            w = Find(w);
            Union(v, w);
        }
    
        int res = 0;
        for (int i = 1; i <= n; ++i) {
            if(parent[i] == i) res++;
        }
    
        cout << "连通分量数:" << res-1 << endl;
        system("pause");
        return 0;
    }
    

    \quad 输入之前那个图信息,运行结果:
    在这里插入图片描述

    展开全文
  • 1、列是同质的 2、不同的列属性必须有不同的属性名 ...3、列的次序无所谓,可以任意交换 ...4、任意两个元组能完全相同 ...6、允许“表套表”,即分量必须取原子值,个分量必须是不可分的数据项 ...

    1、列是同质的

     

    2、不同的列属性必须有不同的属性名

     

    3、列的次序无所谓,可以任意交换

     

    4、任意两个元组不能完全相同

     

    5、行的次序无所谓,可以任意交换

     

    6、不允许“表中套表”,即分量必须取原子值,每一个分量必须是不可分的数据项

    展开全文
  • 不可压缩NS方程求解选用速度,压力为自变量。两者通过守恒方程耦合。   1 自然格式: 速度分量, 压力均在网格节点。 边界条件直接作用在节点上,完美自然边界(Dirichilet B. C), 问题是满足速度无散度,将在...

       

           不可压缩NS方程求解选用速度,压力为自变量。两者通过守恒方程耦合。 

          1 自然格式:  速度分量, 压力均在网格节点。 边界条件直接作用在节点上,完美自然边界(Dirichilet B. C), 问题是满足速度无散度,将在计算中引入非物理的速度。

          2 交错格式(staggered grid): 速度分量在单元边界中点, 压力值在单元中心;无滑移条件不能精确满足。如果将因变量通量(质量,动量)移动到边界中点,又导致因变量通量不精确满足。

          3 局部交错格式: 速度分量在网格节点,压力值在单元中心; 满足无滑移条件,通量在单元边界守恒。压力Dirichilet边界不精确满足,计算复杂,举例: ALE

          4  co-locate格式: 速度分量,压力都存在单元中心;速度,压力边界均不精确满足,但是实现容易,商用软件用的多;

          5  multi-momentum交错格式: 速度分量在单元两方向都计算,压力值位于单元中心。每个速度分量在每个单元边界面上都计算,所以精确满足无滑移/通量守恒,单色计算量较(2)大一倍。


       一  自然差分格式举例  (2D NS, no body force)

             u/t +  u du/dx + v du/dy = - grad_p_x + miu * laplace(u)

            时间差分: backward Euler ;  空间差分: 中心差分

           -- >  非紧致5对角矩阵  A u^(n+1) + B u^n = f^n  <---  时间分裂推进求解速度

           压力波松方程(PPE)   laplace(p) = -2 ( du/dy * dv/dx - du/dx * dv/dy)

     考虑齐次Newman边界 及边界不可穿透条件,上式可解。

         关于压力边界:  Newman问题,不具有唯一解。一般采用给任意初始压力边界,即PPE实际上求解了 Dirichilet - Newman 混合问题,至于这个初始任意压力,对后续计算是没啥影响的。

          自然差分格式算法缺点:

          1   没有保证速度无散度条件,PPE简化中使用了 div_v = 0 , 但 动量方程本身没有求解 div_v = 0. 对于初值满足  div_v = 0 在较短的计算时间内可以满足  div_v =0,但是长时间还算没保证啊。

           2   齐次压力边界只有在  miu -> 0 才满足

          3  中心差分格式诱发速度,压力值的棋盘分布,满足div_v = 0 的伪速度。

           4  div-stability 条件  ??

    差分CFD基本不用自然格式。

      

     二  交错网格格式(FV)

     使用交错网格,2D速度分量和压力共采用三套单元计算,分别即作u单元,v单元 和压力单元。 u,v 单元中心定义单元平均速度, 边线中点定义压力。物理意义上,压力作为一类面力,理应定义在面上。

     考虑x分量    

     LHS 时间导数项  =  d ( u_(i, j-1/2) * hx * hy ) /dt   % u_(i, j - 1/2) 即单元平均速度

     LHS 对流项 = ( u^2_(i+1/2, j-1/2) - u^2_(i-1/2, j-1/2) ) * hy + ( v_(i,j)*u_(i,j) -  v_(i,j-1) * u(i, j-1)  ) * hx  

    其中 u_(i+1/2, j-1/2) = ( u_(i, j-1/2) + u_(i+1, j-1/2) ) / 2 ,  注意 u_(i, j-1/2)即单前单元平均速度, 同理  u_(i-1/2, j-1/2)

    u_(i, j) = ( u(i, j-1/2) + u(i, j+ 1/2)) / 2 %使用y方向平均,  v_(i, j) = ( v(i - 1/2, j) + v( i+1/2, j) ) / 2  % 使用x方向平均

    压力梯度项   =  ( p(i + 1/2, j-1/2) - p(i-1/2, j-1/2) * hy  %单元边界

    扩散项  =   miu * ( ux_(i+1/2, j - 1/2) - ux_(i - 1/2, j - 1/2)) * hy + ( vy_(i, j) - vy_(i, j-1)) * hx ) 

    同理y分量. 整理各项,得到半隐式交错格式有限体积法的NS离散方程。

    上述各项, 只有对流项使用了平均(线性插值), 截断误差分析表明, 该格式整体精度为网格间距的偶数次幂,采用Richardson 外插可进一步提高精度。

    另外,交错格式使用了大量半点的值,实际CFD后处理一般都只计算网格点的值,所以还需要回插网格点值,形成后处理数据。

    最后,u, v速度边界处理, 对于u边界速度 u(i, 1) = 2 U_0 -  u(i, 2);  v边界速度 v(1, j) = V_0

    最最后, 交错网格下的PPE求解,同自然格式,注意Dirichilet边界。


    三  co-locate 差分格式

     所有因变量都在单元中心计算。 诸如, Rhie & Chow算法, Zang算法。后续投影法,SIMPLE算法详细之。

    展开全文
  • 强连通分量求解算法

    千次阅读 2018-10-23 20:32:14
    在有向图,如果顶点v和w相互达,则称这两顶点之间强连通。一幅图任意两点之间强连通则称这幅图为强连通图。有向图的极大强连通子图就是有向图的强连通分量(Strongly Conneted Component)。 强连通有如下...

    强连通分量

    有向图中,如果顶点v和w相互可达,则称这两个顶点之间强连通。一幅图中任意两点之间强连通则称这幅图为强连通图。有向图的极大强连通子图就是有向图的强连通分量(Strongly Conneted Component)。

    强连通有如下性质:

    (1)自反性:任意顶点v和自身是强连通的。

    (2)对称性:如果v和w是强连通的,那么w和v也是强连通的。

    (3)传递性:如果v和w是强连通的且w和x也是强连通的,那么v和x也是强连通的。

    强连通分量即是基于强连通的性质,将相互均为强连通的顶点划分在一起构成的最大子集。强连通性是非常重要的抽象,它突出了相互关联的几组顶点(强连通分量),对事物的分类有很大帮助。

    Kosaraju算法

    Kosaraju算法是求解有向图连通分量较简单的算法,它需要用到原图及其转置图(转置图即所有边的方向与原图一一对应且相反)来进行深度优先搜索。既然强连通是指顶点之间相互可达,那么我们只需要求出原图的连通分量(求解图的连通分量),然后在其转置图中再执行搜寻,原图和转置图对应的每一个连通分量的交集就是我们要求的强连通分量。

    在对转置图进行搜寻的过程中,起始顶点的选择需要有所限制,否则可能搜寻到其他连通分量中,这是不允许的(强连通分量只能存在于单个强连通图,即单棵树中)。Kosaraju算法巧妙地选择了“最晚离开的”顶点,因为对任意顶点v和w假设是强连通的,在第一次搜寻过程中已经得到了v→w,那么就需要证明存在路径使得w→v,即证明转置图中存在路径使得v→w。在对转置图进行深度优先搜索的过程中,dfs(w)肯定在dfs(v)之前就结束了,且在原图中存在v→w即转置图中存在w→v,所以只可能有唯一一种情况——在转置图中对dfs(w)的调用必然在dfs(v)之前结束,因此可以证明该算法思想的正确性。

    对于“最晚离开的”顶点,我们联想栈调用的特性就可以知道,对原图的逆后序遍历得到的顶点顺序就是要对转置图进行深度优先搜索时应遵循的起始顶点顺序。再结合拓扑排序的特点,如果我们把求出来的每个强连通分量收缩成一个点,并且用求出每个强连通分量的顺序来标记收缩后的节点,那么这个顺序其实就是强连通分量收缩成点后形成的有向无环图的拓扑序列。

    综上,Kosaraju算法的执行流程主要是以下两步:

    (1)对原图进行深度优先搜索,得到原图的逆后序遍历的顶点顺序。

    (2)以(1)中的顶点顺序作为对转置图进行深度优先搜索的起始顶点选择顺序,对转置图进行遍历,删除(或标记)能够遍历到的顶点,这些顶点构成一个强连通分量。当还有顶点没有删除或标记时回到(1)继续执行,否则结束。

    /*
     
    struct UndirectedGraph
    {
        size_t V, E; //V表示顶点数,E表示边数
        map<int, forward_list<int>> adj;
    };
    
    */
    
    void get_post_dfs(const DirectedGraph &g, vector<int> &visited, vector<int> &post_order, int v)
    {
        visited.at(v) = 1;
        for (const int &i : g.adj.at(v).second)
        {
            if (visited.at(i) == 0)
            {
                dfs(g, visited, post_reverse_order, i);
            }
        }
        post_reverse_order.push_back(v);
    }
    
    void dfs(const DirectedGraph &g, vector<int> &visited, vector<pair<int, int>> &cc, int v)
    {
        if (visited.at(v) == 1)
        {
            continue;
        }
        g.adj.at(v) = 1;
        for (const int &i : g.adj.at(v))
        {
            if (visited.at(i) == 0)
            {
                cc.push_back(make_pair(v, i));
                dfs(g, visited, cc, i);
            }
        }
    }
    
    vector<vector<pair<int, int>>> FindStronglyConnectedComponent(const DirectedGraph &g, const DirectedGraph &gt) //gt是g的转置图
    {
        vector<vector<pair<int, int>>> ans;
        vector<int> visited(g.V);
        vector<int> post_order;
        get_post_dfs(g, visited, post_order, (*g.adj.cbegin()).first); //得到原图的后序遍历序列(反向即为逆后序)
    
        //标记数组初始化
        for (int &i : visited)
        {
            i = 0;
        }
    
        //对转置图DFS得到强连通分量
        for (auto ite = post_order.crbegin(); ite != post_order.crend(); ++ite)
        {
            vector<pair<int, int>> cc;
            dfs(gt, visited, cc, *ite);
            ans.push_back(move(cc));
        }
        return ans;
    }

     该算法需要进行两次DFS,效率并不算高。对于比较庞大的有向图来说,递归调用容易导致栈溢出,可以将DFS部分用非递归代码来实现。

    Tarjan算法

    Tarjan算法基于强连通分量的一个性质:任何一个强连通分量,必定是对原图进行深度优先搜索得到的子树。所以我们只需要找出每个子树(强连通分量)的根,然后从这棵子树的最底层开始一个一个拿出强连通分量的顶点即可。

    现在关键在于如何找出连通分量的根以及找到根后如何拿出强连通分量的顶点。

    根与其所在连通分量不同之处在于它能够到达其所在连通分量的其他顶点,反之也可达,但不在这个连通分量的顶点到达不了这个根。Tarjan算法的思想是维护两个数组来寻找连通分量的根,其中一个数组dfn用来记录深度优先搜索访问顶点的顺序,另一个数组low则记录一个顶点能到达的最大子树的根(即dfn值最小的顶点)。当一个顶点的dfn值与low值相等时即说明它就是一个连通分量的根。因为如果它不是强连通分量的根,那么它一定是属于另一个强连通分量,而且不是根,那么就存在包含当前顶点的到根的回路,可知low一定会被更改为一个比dfn更小的值,而不是相等。

    至于如何拿出强连通分量,如果当前节点为一个强连通分量的根,那么它的强连通分量一定是以该根为根节点的(剩下节点)子树。在深度优先遍历的时候维护一个栈,每次访问一个新节点,就压入栈。这样,由于当前节点是这个强连通分量中最先被压入堆栈的,那么在当前节点以后压入堆栈的并且仍在堆栈中的节点都属于这个强连通分量。可以用反证法证明这个做法的正确性:假设一个节点在当前节点压入堆栈以后压入并且还存在,同时它不属于该强连通分量,那么它一定属于另一个强连通分量,但当前节点是它的根的祖宗,那么这个强连通分量应该在此之前已经被拿出。

    综上,Tarjan算法的整体流程如下:

    对图进行深度优先遍历,用序号标记遍历到的顶点的先后顺序(对dfn数组赋值)并将新顶点压入栈中,在回溯过程中维护low数组,标记当前顶点能到达的最大子树的根(即dfn值最小的顶点)。在回溯过程中遇到dfn值与low值相等的即为当前连通分量的根。找到根后,此时栈中元素就是该连通分量的顶点,将其一个个拿出即可。

    
    void Tarjan(DirectedGraph &g, vector<vector<int>> &scc_set, vector<int> &visited, vector<int> &dfn, vector<int> &low, vector<int> &in_stack, stack<int> &st)
    {
        dfn[u] = low[u] = ++cnt;
        st.push(u);
        in_stack[u] = 1;
        for (const auto &v : g.adj.at(u))
        {
            if (!visited[v])
            {
                Tarjan(g, v);
                low[v] = min(low[u], low[v]);
            }
            else if (in_stack[v])
            {
                low[u] = min(low[u], dfn[v]);
            }
        }
        if (dfn[u] == low[u])
        {
            vector<int> scc;
            do
            {
                v = st.top();
                st.pop();
                scc.push_back(v);
                in_stack[v] = 0;
            } while (u != v);
            scc_set.push_back(move(scc));
        }
    }
    
    vector<vector<int>> FindStronglyConnectedComponent(DirectedGraph &g)
    {
        static int cnt = 0;
        vector<int> dfn(g.V);    //DFS访问顶点的顺序
        vector<int> low(g.V);    //当前顶点能到达的最大子树的根
        vector<int> visited(g.V);    //访问标记
        stack<int> st;    //存放强连通分量顶点的栈
        vector<int> in_stack(g.V);    //判断顶点是否在栈中
        vector<vector<int>> scc_set;
        for (auto ite = g.adj.cbegin(); ite != g.adj.cend(); ++ite)
        {
            Tarjan(g, scc_set, visited, dfn, low, in_stack, st);
        }
        return scc_set;
    }
    

    运行Tarjan算法的过程中,每个顶点都被访问了一次,且只进出了一次栈,每条边也只被访问了一次,所以该算法的时间复杂度为O(V+E)。在大型连通图中,为了避免递归深度过大而导致效率降低和栈溢出,可以将第一个DFS也改为栈来实现。

    同时在分析Tarjan算法的过程中我们也可以发现,这个算法还可以用于求解无向图的割边桥,已经求解最近公共祖先(LCA)。

     

    展开全文
  • 强连通分量

    万次阅读 热门讨论 2012-05-06 10:45:30
    算法分类: 图论 ...有向图强连通分量: ...在有向图G,如果两顶点间至少存在一条路径,称两顶点...如果有向图G的顶点都强连通,则称G是一强连通图。 非强连通图有向图的极大强连通子图,成为强连通
  • 线性可分支持向量机(一)

    千次阅读 2016-09-24 11:33:26
    基本概念线性可分支持向量机是最基本的形式,对应于两类数据能够被完全分离的的情况。它学习的目标在于在特征空间找到一分离超平面,能够将实例分到不同的类别里。分离超平面对应于方程ωx+b=0。 在另外一篇...
  • 连通分量个数(并查集的应用)

    千次阅读 多人点赞 2016-08-17 15:23:25
    分享出来真是对不起party了。(party:我靠,关我嘛事啊?我跟你很熟么?) 来看一实例,杭电1232畅通工程 首先在地图上给你若干城镇,这些城镇都可以看作点,然后告诉你哪些对城镇之间是有道路直接相连的...
  • 支持向量机的内容有点多,我这里分开进行讲解,所谓的线性可分是对训练样例进行了假设,即假设训练样例是线性可分的,就需要加核函数等步骤处理;所谓的硬间间隔最大化就是假设训练数据没有噪声数据,这样就是硬...
  • 关系模式设计的好与坏的区别

    千次阅读 2015-09-30 21:53:10
    1.元组的每个分量必须是不可分的数据项 关系数据库特别强调,关系中的属性能是组合属性,必须是基本项,并把这一要求规定为鉴别表格是否为“关系”的标准。 2.数据库的数据冗余应尽可能少 数据冗余是数据库最...
  • 双连通分量

    千次阅读 2011-10-16 10:22:09
     在一无向连通图,如果有一顶点集合,删除这顶点集合,以及这集合所有顶点相关联的边以后,原图变成多连通块,就称这点集为割点集合。一图的点连通度的定义为,最小割点集合的顶点数。   ...
  • 文章目录关系的特性数学定义的关系关系的特性关系不可重复候选码/候选键一个关系中可以有多候选码/候选键主码/主键主属性与非主属性外码/外键总结:什么是关系 关系的特性 列的同质性,一列的分量来自与同一...
  • 关系模式

    千次阅读 2019-09-17 21:46:58
    第一范式(1NF):关系模式 R 的个分量不可的数据项,则关系模式 R 属于第一范式。 第二范式(2NF):若关系范式 R∈1NFR\in1NFR∈1NF ,并且一个非主属性完全依赖于码,则关系模式 R∈2NFR\in2NFR∈2NF...
  • 关系数据库系列文章之到底什么是关系(一)

    千次阅读 多人点赞 2018-08-05 02:28:45
    在语言X如何实现Y,像这种具体的只是(know-how)快速提高你的工作效率。但是一旦语言发生变化,这种知识就无法再使用。... 作为程序员,在日常的开发,我们避免了的就要接触数据库这概念,而关系...
  • 【OpenCV】HSV颜色识别-HSV基本颜色分量范围

    万次阅读 多人点赞 2016-05-26 13:59:47
    一般对颜色空间的图像进行有效处理都是在HSV空间进行的,然后对于基本色对应的HSV分量需要给定一严格的范围,下面是通过实验计算的模糊范围(准确的范围在网上都没有给出)。 H: 0 — 180 S: 0 — 255 V: 0 ...
  • 寒假2019培训:双连通分量(点双+边双)

    千次阅读 多人点赞 2019-02-17 20:10:07
    若一无向连通图存在割点,则称它为“点双连通图”。若一无向连通图存在割边,则称它为“边双连通图”。 无向图的极大点双连通子图称为“点双连通分量”,简记为“v-DCC”。无向连通图的极大边双连通子图被...
  • 关系数据库关系数据模型关系是一数学概念。 当把关系的概念引入到数据库系统作为数据模型的数据结构时,既有所限定和也有所扩充。 关系的数学定义例: 课程={离散,C语言…..},学生={张三,李四…..} 笛卡儿积...
  • 数据库关系代数详解

    千次阅读 多人点赞 2021-02-26 16:35:55
    数据库关系代数 1. 关系代数的运算 1.1 传统的关系运算 ...比如说我们每个人都见过成绩单,牢记以下的比喻 R就为整张成绩单 R[A1, A2, A3,…Ai] = R[语文,英语,数学……学科] t为某个同学 t [Ai] 就
  • PCA(主分量分析)

    千次阅读 2011-06-09 14:10:00
    而次分量(Minor Components,MCs)与主分量(Principal Components,PCs)相对,它是混合信号能量最小的成分,被认为是重要的或是噪声有关的信号,把确定次分量的方法称为次分量分析(MCA). PCA可以用于减少...
  • 模式识别:PCA主分量分析与Fisher线性判别分析

    万次阅读 多人点赞 2015-04-23 19:02:03
    本实验的目的是学习和掌握PCA主分量分析方法和Fisher线性判别方法。首先了解PCA主分量分析方法的基本概念,理解利用PCA 分析可以对数据集合在特征空间进行平移和旋转。实验的第二部分是学习和掌握Fisher线性判别方法...
  • 推广到高纬情况,一很自然的想法是,把维度的距离加起来就可以呢。这就形成了传说的一范数:   看,是不是很简单。有一范数就有二范数,三范数。。。无穷范数。其实,二范数来的更加直观,我们都知道二...
  • 层次数据模型     定义:层次数据模型是用树状<...其实层次数据模型就是的图形表示就是一倒立生长的树,由基本数据结构的树(或者二叉树)的定义可知,棵树都有且仅有一根节点,其余的...
  • 关系模型

    千次阅读 2018-07-11 18:31:41
    关系模型 关系模型组成的三要素 关系数据结构 ...关系 关系模式 什么是关系模式 ...实体完整性和参照完整性是关系模型必须满足的完整性约束条件,被称作是关系的两不变性,应该由关系系统自动...
  • 关系模式的规范化

    千次阅读 热门讨论 2015-04-30 17:44:16
     定义:在关系模式R,当且仅当所有域值包含原子值,即每个分量都是不可的数据项,则称关系模式R属于1NF。  用自己的话来形容:1NF即原子性。 举例: 供应者和它所提供的两件信息表 Sno Sname Status...
  • HSV颜色识别-HSV基本颜色分量范围

    万次阅读 多人点赞 2019-03-07 09:09:54
    一般对颜色空间的图像进行有效处理都是在HSV空间进行的,然后对于基本色对应的HSV分量需要给定一严格的范围,下面是通过实验计算的模糊范围(准确的范围在网上都没有给出)。 H: 0—180 S: 0—255 V: 0—255 ...
  • 【数字图像处理】HSV颜色分量

    千次阅读 2017-11-20 13:36:33
    一般对颜色空间的图像进行有效处理都是在HSV空间进行的,然后对于基本色对应的HSV分量需要给定一严格的范围,下面是通过实验计算的模糊范围(准确的范围在网上都没有给出)。 H: 0 — 180 S: 0 — 255...
  • 基于支持向量机的图像分类(上篇)

    万次阅读 多人点赞 2018-03-31 21:25:39
    摘要:本文通过图文详细介绍如何利用支持向量机对图像进行分类。...本文将主要介绍以下几方面: 图像分类任务 收集训练集与测试集 支持向量机分类基本原理 特征选择与提取 用SVM 进行图像分类 分类结果...
  • Kosaraju算法是求解有向图强连通分量(strong connectedcomponent)的三著名算法之一,能在线性时间求解出一图的强分量。 什么是强连通分量?在这之前先定义一强连通性(strong connectivi
  • 强连通分量(strongly connected components)

    千次阅读 2018-08-04 12:30:05
    强连通分量(strongly connected components)  徐不可说 2018/8/4 ...
  • 关系演算

    千次阅读 2017-12-10 15:35:31
    关系演算是以数理逻辑的谓词演算为基础的。按谓词变元的不同,关系演算分为元组关系演算和域关系演算。 一、元组关系演算语言ALPHA元组关系演算以元组变量作为谓词变元的基本对象。元组变量是在某一关系范围内...
  • 在用户看来,关系模型数据的逻辑结构是一张扁平的二维表。 1.1域 域是一组具有相同数据类型值的集合。 1.2笛卡儿积 笛卡儿积是域上的一种集合运算。 定义:给定一组域D1,D2,...,Dn,允许其中某些域是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 41,308
精华内容 16,523
关键字:

关系中每个分量必须是不可分