精华内容
下载资源
问答
  • 简单方法判断邻接矩阵的有向图是否有环求解思路实现代码如有不同见解,欢迎讨论 求解思路 1.统计所有节点出度及其前序节点,初始化一个空访问集合; 2.将出度为零节点放入访问集合,并将其前序节点出度数减1...

    简单方法判断邻接矩阵的有向图是否有环

    求解思路

    1.统计所有节点的出度及其前序节点,初始化一个空的访问集合;
    2.将出度为零的节点放入访问集合,并将其前序节点的出度数减1;
    3.重复第2步骤,直到所有节点从头到尾完整遍历一遍;
    4.判断已访问节点个数是否等于节点个数,是则有向图无环,否则有向图有环。

    实现代码

    import java.util.HashMap;
    import java.util.HashSet;
    import java.util.Map;
    import java.util.Set;
    
    public class AlgorithmUtil {
        /**
         * 判断有向图是否有环
         * 根据每个节点的入度和出度计算,把出度为零的依次去掉并更改其前序节点的出度个数,统计最后访问过的节点个数
         */
        public static boolean isDag(int[][] graph) {
            int nodeNum = graph.length;
            // 记录每个有入度的节点,及其所有的前序节点
            Map<Integer, List<Integer>> inEdge = new HashMap<>(nodeNum);
            // 记录每个节点的出度个数
            int[] outEdgeNum = new int[nodeNum];
            // 初始化数据
            for (int i = 0; i < nodeNum; i++) {
                for (int j = 0; j < nodeNum; j++) {
                    if (graph[i][j] != Integer.MAX_VALUE) {
                        outEdgeNum[i]++;
                        if (inEdge.get(j) == null) {
                            List<Integer> list = new ArrayList<>();
                            list.add(i);
                            inEdge.put(j, list);
                        } else {
                            inEdge.get(j).add(i);
                        }
                    }
                }
            }
    
            // 已访问的节点
            Set<Integer> visitedSet = new HashSet<>(nodeNum);
            // 循环遍历所有节点的出度
            while (visitedSet.size() < nodeNum) {
                for (int i = 0; i < nodeNum; i++) {
                    if (outEdgeNum[i] == 0 && !visitedSet.contains(i)) {
                        visitedSet.add(i);
                        for (int temp = 0; inEdge.get(i) != null && temp < inEdge.get(i).size(); temp++) {
                            outEdgeNum[inEdge.get(i).get(temp)]--;
                        }
                        break;
                    }
                    // 节点遍历一遍后,判断是否访问了过所有节点
                    if ((i == nodeNum - 1) && visitedSet.size() != nodeNum) {
                        return true;
                    }
                }
            }
    
            return false;
        }
    }
    

    测试用例

    import org.junit.Test;
    
    public class AlgorithmUtilTest {
    
        private int NAN = Integer.MAX_VALUE;
    
        @Test
        public void isDag() {
            int[][] graph = new int[][] {{NAN, 1, 1, NAN}, {NAN, NAN, NAN, 1}, {NAN, NAN, NAN, 1}, {NAN, NAN, NAN, NAN}};
            assert !AlgorithmUtil.isDag(graph);
        }
    
        @Test
        public void isDag2() {
            int[][] graph = new int[][] {{NAN, 1, 1, NAN}, {1, NAN, NAN, 1}, {NAN, NAN, NAN, 1}, {NAN, NAN, NAN, NAN}};
            assert AlgorithmUtil.isDag(graph);
        }
    
        @Test
        public void isDag3() {
            int[][] graph = new int[][] {{NAN, 1, 1, NAN}, {NAN, NAN, NAN, 1}, {NAN, NAN, NAN, 1}, {1, NAN, NAN, NAN}};
            assert AlgorithmUtil.isDag(graph);
        }
    }
    

    知识背景

    leetcode 207题 课程表
    简单方法查找邻接矩阵有向图的有序集合
    如有不同见解,欢迎留言讨论

    展开全文
  • 简单方法查找邻接矩阵有向图的有序集合求解思路实现代码测试用例知识背景 求解思路 1.统计所有节点出度及其前序节点,初始化一个空访问集合; 2.将出度为零节点放入访问集合,并将其前序节点出度数减1; 3....

    简单方法查找邻接矩阵有向图的有序集合

    求解思路

    1.统计所有节点的出度及其前序节点,初始化一个空的访问集合;
    2.将出度为零的节点放入访问集合,并将其前序节点的出度数减1;
    3.重复第2步骤,直到所有节点从头到尾完整遍历一遍;
    4.判断已访问节点个数是否等于节点个数,是则有向图无环,否则有向图有环。

    实现代码

    方法一:

    import java.util.ArrayList;
    import java.util.Collections;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    import java.util.stream.Collectors;
    
    public class AlgorithmUtil {
        /**
         * 查找有向图的有序集合,如果有环返回空数组
         * 根据每个节点的入度和出度计算,把出度为零的依次去掉并更改其前序节点的出度个数,统计最后访问过的节点
         */
        public static int[] findSequence(int[][] graph) {
            int nodeNum = graph.length;
            // 记录每个有入度的节点,及其所有的前序节点
            Map<Integer, List<Integer>> inEdge = new HashMap<>(nodeNum);
            // 记录每个节点的出度个数
            int[] outEdgeNum = new int[nodeNum];
            // 初始化数据
            for (int i = 0; i < nodeNum; i++) {
                for (int j = 0; j < nodeNum; j++) {
                    if (graph[i][j] != Integer.MAX_VALUE) {
                        outEdgeNum[i]++;
                        if (inEdge.get(j) == null) {
                            List<Integer> list = new ArrayList<>();
                            list.add(i);
                            inEdge.put(j, list);
                        } else {
                            inEdge.get(j).add(i);
                        }
                    }
                }
            }
    
            // 已访问的节点个数
            List<Integer> visitedList = new ArrayList<>(nodeNum);
            // 循环遍历所有节点的出度
            while (visitedList.size() < nodeNum) {
                for (int i = 0; i < nodeNum; i++) {
                    if (outEdgeNum[i] == 0 && !visitedList.contains(i)) {
                        visitedList.add(i);
                        for (int temp = 0; inEdge.get(i) != null && temp < inEdge.get(i).size(); temp++) {
                            outEdgeNum[inEdge.get(i).get(temp)]--;
                        }
                        break;
                    }
                    if ((i == nodeNum - 1) && visitedList.size() != nodeNum) {
                        return new int[] {};
                    }
                }
            }
            // 反转集合元素
            Collections.reverse(visitedList);
            int[] result = visitedList.stream().mapToInt(Integer::valueOf).toArray();
            return result;
        }
    }
    

    性能优化

    方法一虽好但是使用集合太多,性能有瓶颈。优化方法是减少集合使用。

    
    import java.util.HashMap;
    import java.util.Map;
    import java.util.HashSet;
    import java.util.Set;
    
    public class AlgorithmUtil {
        /**
         * 查找有向图的有序集合,如果有环返回空数组
         * 根据每个节点的入度和出度计算,把出度为零的依次去掉并更改其前序节点的出度个数,统计最后访问过的节点
         */
        public static int[] findSequence(int[][] graph) {
            int nodeNum = graph.length;
            // 记录每个有入度的节点,及其所有的前序节点
            Map<Integer, List<Integer>> inEdge = new HashMap<>(nodeNum);
            // 记录每个节点的出度个数
            int[] outEdgeNum = new int[nodeNum];
            // 初始化数据
            for (int i = 0; i < nodeNum; i++) {
                for (int j = 0; j < nodeNum; j++) {
                    if (graph[i][j] != Integer.MAX_VALUE) {
                        outEdgeNum[i]++;
                        if (inEdge.get(j) == null) {
                            List<Integer> list = new ArrayList<>();
                            list.add(i);
                            inEdge.put(j, list);
                        } else {
                            inEdge.get(j).add(i);
                        }
                    }
                }
            }
    
            int[] visited = new int[nodeNum];
            int index = 0;
            Set<Integer> visitedSet = new HashSet<>(nodeNum);
            while (index < nodeNum) {
                for (int i = 0; i < nodeNum; i++) {
                    if (outEdgeNum[i] == 0 && !visitedSet.contains(i)) {
                        visited[index++] = i;
                        visitedSet.add(i);
                        for (int temp = 0; inEdge.get(i) != null && temp < inEdge.get(i).size(); temp++) {
                            outEdgeNum[inEdge.get(i).get(temp)]--;
                        }
    
                        break;
                    }
                    if ((i == nodeNum - 1) && visitedSet.size() != nodeNum) {
                        return new int[] {};
                    }
                }
            }
            reverseArray(visited);
            return visited;
        }
    	
    	/**
         * 数组反转
         * @param array 数组
         */
        private static void reverseArray(int[] array) {
            for (int i = 0; i < array.length / 2; i++) {
                int temp = array[i];
                array[i] = array[array.length - 1 - i];
                array[array.length - 1 - i] = temp;
            }
        }
    }
    

    测试用例

    import org.junit.Test;
    
    public class AlgorithmUtilTest {
    
        @Test
        public void findSequence() {
            int[][] graph = new int[][] {{NAN, 1, 1, NAN}, {NAN, NAN, NAN, 1}, {NAN, NAN, NAN, 1}, {NAN, NAN, NAN, NAN}};
            int[] resp = AlgorithmUtil.findSequence(graph);
            int[] goal = new int[] {0, 1, 2, 3};
            int[] goal2 = new int[] {0, 2, 1, 3};
            assert isEqual(resp, goal) || isEqual(resp, goal2);
        }
    
        @Test
        public void findSequence2() {
            int[][] graph = new int[][] {{NAN, 1, 1, NAN}, {1, NAN, NAN, 1}, {NAN, NAN, NAN, 1}, {NAN, NAN, NAN, NAN}};
            int[] resp = AlgorithmUtil.findSequence(graph);
            int[] goal = new int[] {};
            assert isEqual(resp, goal);
        }
    
        @Test
        public void findSequence3() {
            int[][] graph = new int[][] {{NAN, 1, 1, NAN}, {NAN, NAN, NAN, 1}, {NAN, NAN, NAN, 1}, {1, NAN, NAN, NAN}};
            int[] resp = AlgorithmUtil.findSequence(graph);
            int[] goal = new int[] {};
            assert isEqual(resp, goal);
        }
    
        @Test
        public void findSequence4() {
            int[][] graph = new int[][] {{NAN, 1, NAN, NAN, NAN, NAN, NAN}, {NAN, NAN, NAN, NAN, NAN, NAN, NAN},
                {1, NAN, NAN, 1, NAN, NAN, NAN}, {1, NAN, NAN, NAN, NAN, NAN, NAN}, {NAN, NAN, 1, NAN, NAN, NAN, NAN},
                {NAN, NAN, 1, NAN, 1, NAN, NAN}, {NAN, NAN, NAN, NAN, NAN, 1, NAN}};
            int[] resp = AlgorithmUtil.findSequence(graph);
            int[] goal = new int[] {6, 5, 4, 2, 3, 0, 1};
            assert isEqual(resp, goal);
        }
    
        private boolean isEqual(int[] numA, int[] numB) {
            if (numA.length == numB.length) {
                for (int i = 0; i < numA.length; i++) {
                    if (numA[i] != numB[i]) {
                        return false;
                    }
                }
                return true;
            }
            return false;
        }
    }
    

    知识背景

    leetcode 210. 课程表 II
    简单方法判断邻接矩阵的有向图是否有环

    如有不同见解,欢迎留言讨论

    展开全文
  • 而在快速排序中,记录比较和移动都是从两端中间进行。 其主要思想:首先在待排序数组中选取一个基准值(作为边缘检测算法基本步骤(1)滤波。边缘检测主要基于导数计算,但受噪声影响。但滤波器在降低噪声...

    快速排序 一、 算法描述 快速排序是对冒泡排序的一种改进。在冒泡排序中,记录每次都是与相邻位置上的数据作比较,因此每次只能移动一个位置。而在快速排序中,记录的比较和移动都是从两端向中间进行的。 其主要思想:首先在待排序数组中选取一个基准值(作为

    边缘检测算法的基本步骤(1)滤波。边缘检测主要基于导数计算,但受噪声影响。但滤波器在降低噪声的同时也导致边缘强度的损失。 (2)增强。增强算法将邻域中灰度有显著变化的点突出显示。一般通过计算梯度幅值完成。

    (3)检测。但在有些图象中梯度幅值较大的并不是边缘点。最简单的边缘检测是梯度幅值阈值判定。

    (4)定位。精确确定边缘的位置。

    Canny边缘检测算法step1:用高斯滤波器平滑图象;

    step2:用一阶偏导的有限差分来计算梯度的幅值和方向;

    step3:对梯度幅值进行非极大值抑制;

    step4:用双阈值算法检测和连接边缘。

    效果图如下:

    F

    代码如下:最近在学习缓存算法, 就自己用java实现了一个LRU缓存算法,其实LRU可以直接用LinkedHashMap直接实现,本文采用HashMap来进行构造代码如下: *public class LRUCache{ private class CacheElemet{ private CacheElemet befor

    package tools;

    import java.awt.*;

    import java.awt.image.*;

    public class EdgeDetector extends Component {

    public EdgeDetector() {

    threshold1 = 50;

    threshold2 = 230;

    setThreshold(128);

    setWidGaussianKernel(15);

    }

    public void process() throws EdgeDetectorException {

    if (threshold < 0 || threshold > 255)

    throw new EdgeDetectorException("The value of the threshold is out of its valid range.");

    if (widGaussianKernel < 3 || widGaussianKernel > 40)

    throw new EdgeDetectorException("The value of the widGaussianKernel is out of its valid range.");

    width = sourceImage.getWidth(this);

    height = sourceImage.getHeight(this);

    picsize = width * height;

    data = new int[picsize];

    magnitude = new int[picsize];

    orientation = new int[picsize];

    float f = 1.0F;

    canny_core(f, widGaussianKernel);

    thresholding_tracker(threshold1, threshold2);

    for (int i = 0; i < picsize; i++)

    if (data[i] > threshold)

    data[i] = 0xff000000;

    else

    data[i] = -1;

    edgeImage = pixels2image(data);

    data = null;

    magnitude = null;

    orientation = null;

    }

    private void canny_core(float f, int i) {

    boolean flag = false;

    boolean flag1 = false;

    derivative_mag = new int[picsize];

    float af4[] = new float[i];

    float af5[] = new float[i];

    float af6[] = new float[i];

    data = image2pixels(sourceImage);

    int k4 = 0;

    do {

    if (k4 >= i)

    break;

    float f1 = gaussian(k4, f);

    if (f1 <= 0.005F && k4 >= 2)

    break;

    float f2 = gaussian((float) k4 - 0.5F, f);

    float f3 = gaussian((float) k4 + 0.5F, f);

    float f4 = gaussian(k4, f * 0.5F);

    af4[k4] = (f1 + f2 + f3) / 3F / (6.283185F * f * f);

    af5[k4] = f3 - f2;

    af6[k4] = 1.6F * f4 - f1;

    k4++;

    } while (true);

    int j = k4;

    float af[] = new float[picsize];

    float af1[] = new float[picsize];

    int j1 = width - (j - 1);

    int l = width * (j - 1);

    int i1 = width * (height - (j - 1));

    for (int l4 = j - 1; l4 < j1; l4++) {

    for (int l5 = l; l5 < i1; l5 += width) {

    int k1 = l4 + l5;

    float f8 = (float) data[k1] * af4[0];

    float f10 = f8;

    int l6 = 1;

    int k7 = k1 - width;

    for (int i8 = k1 + width; l6 < j; i8 += width) {

    f8 += af4[l6] * (float) (data[k7] + data[i8]);

    f10 += af4[l6] * (float) (data[k1 - l6] + data[k1 + l6]);

    l6++;

    k7 -= width;

    }

    af[k1] = f8;

    af1[k1] = f10;

    }

    }

    float af2[] = new float[picsize];

    for (int i5 = j - 1; i5 < j1; i5++) {

    for (int i6 = l; i6 < i1; i6 += width) {

    float f9 = 0.0F;

    int l1 = i5 + i6;

    for (int i7 = 1; i7 < j; i7++)

    f9 += af5[i7] * (af[l1 - i7] - af[l1 + i7]);

    af2[l1] = f9;

    }

    }

    af = null;

    float af3[] = new float[picsize];

    for (int j5 = k4; j5 < width - k4; j5++) {

    for (int j6 = l; j6 < i1; j6 += width) {

    float f11 = 0.0F;

    int i2 = j5 + j6;

    int j7 = 1;

    for (int l7 = width; j7 < j; l7 += width) {

    f11 += af5[j7] * (af1[i2 - l7] - af1[i2 + l7]);

    j7++;

    }

    af3[i2] = f11;

    }

    }

    af1 = null;

    j1 = width - j;

    l = width * j;

    i1 = width * (height - j);

    for (int k5 = j; k5 < j1; k5++) {

    for (int k6 = l; k6 < i1; k6 += width) {

    int j2 = k5 + k6;

    int k2 = j2 - width;

    int l2 = j2 + width;

    int i3 = j2 - 1;

    int j3 = j2 + 1;

    int k3 = k2 - 1;

    int l3 = k2 + 1;

    int i4 = l2 - 1;

    int j4 = l2 + 1;

    float f6 = af2[j2];

    float f7 = af3[j2];

    float f12 = hypotenuse(f6, f7);

    int k = (int) ((double) f12 * 20D);

    derivative_mag[j2] = k >= 256 ? 255 : k;

    float f13 = hypotenuse(af2[k2], af3[k2]);

    float f14 = hypotenuse(af2[l2], af3[l2]);

    float f15 = hypotenuse(af2[i3], af3[i3]);

    float f16 = hypotenuse(af2[j3], af3[j3]);

    float f18 = hypotenuse(af2[l3], af3[l3]);

    float f20 = hypotenuse(af2[j4], af3[j4]);

    float f19 = hypotenuse(af2[i4], af3[i4]);

    float f17 = hypotenuse(af2[k3], af3[k3]);

    float f5;

    if (f6 * f7 <= (float) 0

    ? Math.abs(f6) >= Math.abs(f7)

    ? (f5 = Math.abs(f6 * f12))

    >= Math.abs(f7 * f18 - (f6 + f7) * f16)

    && f5

    > Math.abs(f7 * f19 - (f6 + f7) * f15) : (

    f5 = Math.abs(f7 * f12))

    >= Math.abs(f6 * f18 - (f7 + f6) * f13)

    && f5

    > Math.abs(f6 * f19 - (f7 + f6) * f14) : Math.abs(f6)

    >= Math.abs(f7)

    ? (f5 = Math.abs(f6 * f12))

    >= Math.abs(f7 * f20 + (f6 - f7) * f16)

    && f5

    > Math.abs(f7 * f17 + (f6 - f7) * f15) : (

    f5 = Math.abs(f7 * f12))

    >= Math.abs(f6 * f20 + (f7 - f6) * f14)

    && f5 > Math.abs(f6 * f17 + (f7 - f6) * f13)) {

    magnitude[j2] = derivative_mag[j2];

    orientation[j2] = (int) (Math.atan2(f7, f6) * (double) 40F);

    }

    }

    }

    derivative_mag = null;

    af2 = null;

    af3 = null;

    }

    private float hypotenuse(float f, float f1) {

    if (f == 0.0F && f1 == 0.0F)

    return 0.0F;

    else

    return (float) Math.sqrt(f * f + f1 * f1);

    }

    private float gaussian(float f, float f1) {

    return (float) Math.exp((-f * f) / ((float) 2 * f1 * f1));

    }

    private void thresholding_tracker(int i, int j) {

    for (int k = 0; k < picsize; k++)

    data[k] = 0;

    for (int l = 0; l < width; l++) {

    for (int i1 = 0; i1 < height; i1++)

    if (magnitude[l + width * i1] >= i)

    follow(l, i1, j);

    }

    }

    private boolean follow(int i, int j, int k) {

    int j1 = i + 1;

    int k1 = i - 1;

    int l1 = j + 1;

    int i2 = j - 1;

    int j2 = i + j * width;

    if (l1 >= height)

    l1 = height - 1;

    if (i2 < 0)

    i2 = 0;

    if (j1 >= width)

    j1 = width - 1;

    if (k1 < 0)

    k1 = 0;

    if (data[j2] == 0) {

    data[j2] = magnitude[j2];

    boolean flag = false;

    int l = k1;

    do {

    if (l > j1)

    break;

    int i1 = i2;

    do {

    if (i1 > l1)

    break;

    int k2 = l + i1 * width;

    if ((i1 != j || l != i)

    && magnitude[k2] >= k

    && follow(l, i1, k)) {

    flag = true;

    break;

    }

    i1++;

    } while (true);

    if (!flag)

    break;

    l++;

    }

    while (true);

    return true;

    } else {

    return false;

    }

    }

    private Image pixels2image(int ai[]) {

    展开全文
  • C++输出有向无环图的拓扑序列1,拓扑序列拓扑序列概念拓扑序列应用2,拓扑排序步骤3,举例4,代码实现 1,拓扑序列 拓扑序列概念 在一个有向无环中,若有弧 < i , j > 存在,则在拓扑序列中, i 一定...


    1,拓扑序列

    拓扑序列的概念

    在一个有向无环图中,若有弧 < i , j > 存在,则在拓扑序列中, i 一定排在 j 的前面,具有这种性质的线性序列称为拓扑有序序列。

    拓扑序列的应用

    (1)可以获得相互关联的若干事件的执行顺序;
    (2)可以判断一个有向图中是否有回路(环)。


    2,拓扑排序步骤

    (1)在有向图中选取一个入度为 0 (即没有前驱顶点)的顶点。

    (2)保存该顶点至输出结果中,从图中删除该顶点及与该顶点相连的弧。

    (3)重复(1)(2)步,直到所有的顶点都已输出或图中没有前驱为 0 的顶点为止。


    3,举例

    在这里插入图片描述
    如图,
    (1)选择入度为 0 的顶点 v0, 将其保存到数组 result 中,删除 v0 及与其相连的弧。

    在这里插入图片描述
    (2)继续选择入度为 0 的顶点,可以选 v3, 也可以选 v1, 这里选 v1, 将其保存到数组 result 中,删除 v1 及与其相连的弧。

    在这里插入图片描述
    (3)继续选择入度为 0 的顶点,可以选 v3, 也可以选 v2, 这里选 v2, 将其保存到数组 result 中,删除 v2 及与其相连的弧。

    在这里插入图片描述
    (4)继续选择入度为 0 的顶点,为 v3, 将其保存到数组 result 中,删除 v3 及与其相连的弧。此时只剩下 v4 ,且其入度为 0 ,继续选择一次将其保存到数组 result 中,排序结束。

    result 数组的数据: 0, 1, 2, 3, 4 即为一个拓扑序列。


    4,代码实现

    #include<iostream>
    #include<queue>
    #include<vector>
    using namespace std;
    
    #define Max 9999
    int n, m; // n为顶点数,m为边数
    int G[Max][Max];
    int inDegree[Max];
    vector<int> result;//记录结果
    
    void topsort()
    {
    	queue<int> node; // 用来保存入度为 0 的顶点
    	for (int i = 0; i < n; ++i)
    	{
    		if (inDegree[i] == 0)
    		{
    			node.push(i);
    			inDegree[i] = -1;
    		}
    	}
    	if (node.empty())
    	{
    		cout << "该图无拓扑排序" << endl;
    		return;
    	}
    	while (!node.empty())
    	{ 
    		int temp = node.front();
    		node.pop();
    		for (int i = 0; i < n; ++i)
    		{
    			if (G[temp][i] != 0)  //删除与所选顶点相连的弧并让弧的另一个顶点入度减一
    			{
    				inDegree[i]--;
    				G[temp][i] = 0;
    			}
    			if (inDegree[i] == 0)  //若顶点的入度为 0 ,则将其加入队列
    			{
    				node.push(i);
    				inDegree[i] = -1;
    			}
    		}
    		result.push_back(temp);
    	}
    	if (result.size() < n) // 判断图中的顶点是否全部加入
    	{
    		cout << "该图无拓扑排序" << endl;
    	}
    	else
    	{
    		cout << "该图的一个拓扑排序为:" << endl;
    		for (int i = 0; i < result.size(); ++i)
    		{
    			cout << result[i] << " ";
    		}
    	}
    }
    int main()
    {
    	cout << "输入顶点数:";
    	cin >> n;
    	cout << "输入边数:";
    	cin >> m;
    	cout << "输入各边的信息:";
    	fill(G[0], G[0] + Max * Max, 0);
    	fill(inDegree, inDegree + Max, 0);
    	int u, v; //u为前驱节点,v为后继节点
    	for (int i = 0; i < m; ++i)
    	{
    		cin >> u >> v;
    		G[u][v]++;
    		inDegree[v]++;  //入度加一
    	}
    	topsort();
    
    	return 0;
    }
    

    输入输出信息:在这里插入图片描述
    在这里插入图片描述

    展开全文
  •  (2)项目中添加保存“新闻”数据plist文件 (3)导入用到图片素材 2.步骤代码 (1)新建一个数据模型 该模型的代码设计如下:   YYnews.h文件 代码如下: // // YYnews.h // 08-无限滚动(新闻...
  • 轮播图实现主要三部分构成: ①.轮播图片 ②.轮播图片计时器 ③.轮播图片控制器 1.设计轮播容器: 使用.carousel类设计轮播图片容器,并为该容器添加id,方便后面使用 <div id="slidershow" class...
  • 已知有向图,顶点从0开始编号,求它求拓扑有序序列。 拓扑排序算法:给出有向图邻接矩阵 1.逐列扫描矩阵,找出入度为0且编号最小顶点v 2.输出v,并标识v已访问 3.把矩阵第v行全清0 重复上述步骤,直到所有顶点...
  • 两种方法:方法一:就是使用代码在编辑器进行编辑emmmmmm这个方法贼麻烦,需要调至HTML模式……方法二:在现有编辑器模板下利用SVG动画进行编辑,因为点亮效果本质上就是一张灰白图片一张彩色图片叠加,下面步骤...
  • 页面效果: 右下角按钮是可以随着大图的运动而改变其透明度,文字颜色 当用户不去点击时,大图有个自动轮播效果,每隔2秒回自动...实现这个小效果的步骤如下: 第一步:首先布局 HTML代码如下: C...
  • 有向无环 LCA。给定一幅有向无环和两个顶点 v 和 w,找出 v 和 w LCA( Lowest Common Ancestor, 最近共同祖先)。 如上所示:LCA(5,6) = 3、LCA(5,7) = 1、LCA(5,1) = 1。 二、Tarjan算法 ...
  • 因为弹性运动我在弹性菜单实例中已经列过详细的步骤了,所以此处不再赘述,不懂的或兴趣的请点击原生js实现弹性菜单这个例子里面我们主要解决的问题1、弹性运动的实现(不再详细讲解)2、怎样判断鼠标是左...
  • 今天我就以图片上传为例大家展示文件上传功能具体步骤。 其实文件上传两种方法,一种是from表单submit提交,一种是ajax实现异步提交,可是form表单提交个问题就是每次在上传完成时会刷新界面,不能实现异步...
  • 《Orange S:一个操作系统的实现》从只有二十行的引导扇区代码出发,一步一步地读者呈现一个操作系统框架的完成过程。书中不仅关注代码本身,同时关注完成这些代码的思路和过程。本书不同于其他的理论型书籍,而是...
  • 注:此算法存在诸多问题,无法解决规模比较大案例。 算法设计步骤: 第一步:建图(邻接矩阵):运用官方提供函数接口实现读取,图建立自己实现。...有向图的建立,http://jingyan.baidu.com/artic
  • 车牌定位方法很多种,这里我们从汽车图像纹理特征入手,找出车牌不同于背景特征是车牌定位关键。观察多幅汽车图片我们会发现车身和背景纹理多为横向纹理,而车牌字符则为竖纹理,基于这个纹理特征我们...
  • 大家好,这篇文章我要给大家分享一个网页文件上传功能的代码,希望大家可以有所参考...今天我就以图片上传为例大家展示文件上传功能具体步骤。其实文件上传两种方法,一种是from表单submit提交,一种是ajax实现
  • 判断是否

    千次阅读 2018-08-16 01:03:33
    我们知道对于环1-2-3-4-1,每个节点度都是2,基于此我们有如下算法(这是类似于有向图的拓扑排序): 求出图中所有顶点度, 删除图中所有度&lt;=1顶点以及与该顶点相关边,把与这些边相关顶点度减...
  • 有向无环图(Directed Acyclic Graph,DAG):有向图中任何一个顶点都无法通过一些有向边回到自身。 拓扑排序:将有向无环图G所有顶点排成一个线性序列,使得对图G中任意两个顶点u、v,如果存在边u->v,那么在序列...
  • 7.对有向图的深度优先遍历 二:广度优先遍历 1.定义 2.搜索步骤 3.图表达流程 举例: 代码实现: 4.对无向图广度优先遍历图解 5.对有向图的广度优先遍历图解 三:异同 1.同 2.异 ...
  • 在最近开发中,这样一个需求,按住按钮实现帧序列变化,实现向前播放动画或者后倒退动画。我试了几种方法,最终实现了这一个效果。具体实现方法如下所示: 实现步骤 1.新建工程,导入序列帧,如下所...
  • 用java实现的词法分析和语法分析小程序 :carp_streamer: 个人博客网站: : :heart_with_ribbon: :television:结果 词法分析 语法分析 判断是否是LL(1)文法 概述 词法分析:根据输入字符序列,将字符序列...
  • 的实现可以用顺序也可以用链式。它遵循先进后出原则,如下: <img alt="" src="http://my.csdn.net/uploads/201204/27/1335456338_3813.png" /><br /> Java中测试代码如下: <pre><code...
  • 在一些网站上可以经常看到一些图片进行持续不断滚动,这个效果可以通过css动画效果来实现。具体效果如下 主要原理是通过动画左移动。 首先给出两组一样图片(同一行上),让整体图片左移动一组图片...
  • 2.后端咱们写个简单 websocket服务,由于时间有限我会抽空分步写出实现步骤,需要同学关注,当然如果本身是大神可以绕道。先给大家看一下效果登录好友聊天换肤功能消息提示好友消息提示最近联系人和群图片发送...
  • 本片主要以类图的方式大家介绍插件化框架的实现。下是框架的初始化流程: 框架初始化后,就该启动插件了,下是插件的启动流程: 这个步骤主要是初始化插件的运行环境,利用宿主的Context...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 428
精华内容 171
关键字:

有向图代码的实现步骤