Naloga 4 WIP

naloga4/.gitignore

@@ -0,0 +1,29 @@
+### IntelliJ IDEA ###
+out/
+!**/src/main/**/out/
+!**/src/test/**/out/
+
+### Eclipse ###
+.apt_generated
+.classpath
+.factorypath
+.project
+.settings
+.springBeans
+.sts4-cache
+bin/
+!**/src/main/**/bin/
+!**/src/test/**/bin/
+
+### NetBeans ###
+/nbproject/private/
+/nbbuild/
+/dist/
+/nbdist/
+/.nb-gradle/
+
+### VS Code ###
+.vscode/
+
+### Mac OS ###
+.DS_Store

naloga4/.idea/.gitignore

@@ -0,0 +1,10 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Environment-dependent path to Maven home directory
+/mavenHomeManager.xml
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

naloga4/.idea/dictionaries/project.xml

@@ -0,0 +1,7 @@
+<component name="ProjectDictionaryState">
+  <dictionary name="project">
+    <words>
+      <w>graf</w>
+    </words>
+  </dictionary>
+</component>

naloga4/.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,19 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="PyPep8Inspection" enabled="true" level="INFORMATION" enabled_by_default="true">
+      <option name="ignoredErrors">
+        <list>
+          <option value="W292" />
+        </list>
+      </option>
+    </inspection_tool>
+    <inspection_tool class="PyUnresolvedReferencesInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ignoredIdentifiers">
+        <list>
+          <option value="tests.smoke.test_absences_sliding.TestAbsencesSliding.*" />
+        </list>
+      </option>
+    </inspection_tool>
+  </profile>
+</component>

naloga4/.idea/misc.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" languageLevel="JDK_24" default="true" project-jdk-name="homebrew-23" project-jdk-type="JavaSDK">
+    <output url="file://$PROJECT_DIR$/out" />
+  </component>
+</project>

naloga4/.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/naloga4.iml" filepath="$PROJECT_DIR$/naloga4.iml" />
+    </modules>
+  </component>
+</project>

naloga4/.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$/.." vcs="Git" />
+  </component>
+</project>

naloga4/naloga4.iml

@@ -0,0 +1,11 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="JAVA_MODULE" version="4">
+  <component name="NewModuleRootManager" inherit-compiler-output="true">
+    <exclude-output />
+    <content url="file://$MODULE_DIR$">
+      <sourceFolder url="file://$MODULE_DIR$/src" isTestSource="false" />
+    </content>
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

naloga4/src/Graf.java

@@ -0,0 +1,280 @@
+public class Graf {
+    private final Node[] nodes;
+    private final MaxHeap<Node> heap = new MaxHeap<>();
+
+    Graf(int n) {
+        this.nodes = new Node[n];
+        for (int i = 0; i < n; i++) {
+            Node node = new Node(i);
+            nodes[i] = node;
+            heap.insert(node);
+        }
+    }
+
+    void povezi(int u, int v) {
+        nodes[u].degree++;
+        nodes[v].degree++;
+        nodes[u].neighbors.add(nodes[v]);
+        nodes[v].neighbors.add(nodes[u]);
+//        heap.heapify(u);
+//        heap.heapify(v);
+        heap.rebuild();
+    }
+
+    void pozresni() {
+        ArrList<Integer> used = new ArrList<>();
+
+        while (!heap.isEmpty()) {
+            Node node = heap.pop();
+            if (node.degree == 0) {
+                break;
+            }
+
+            LinkedList<Node>.Node neighbor = node.neighbors.root;
+            do {
+                neighbor.value.degree--;
+                heap.heapify(neighbor.value.id);
+                neighbor = neighbor.next;
+            } while (neighbor != null);
+
+            used.add(node.id);
+        }
+
+        print(used);
+    }
+
+    private void print(ArrList<Integer> arr) {
+        int idxStart = arr.size() > 100 ? arr.size() - 100 : 0;
+        for (int i = idxStart; i < arr.size(); i++) {
+            System.out.print(arr.get(i));
+            if (i < arr.size() - 1) System.out.print(" ");
+        }
+        System.out.println();
+    }
+}
+
+class Node implements Comparable<Node> {
+    int id;
+    int degree = 0;
+    LinkedList<Node> neighbors = new LinkedList<>();
+
+    Node(int id) {
+        this.id = id;
+    }
+
+    @Override
+    public int compareTo(Node other) {
+        int deg = Integer.compare(this.degree, other.degree);
+        if (deg == 0) {
+            return Integer.compare(other.id, this.id);
+        }
+        return deg;
+    }
+
+    @Override
+    public String toString() {
+        return "Node [id=" + id + ", degree=" + degree + "]";
+    }
+}
+
+class MaxHeap<T extends Comparable<T>> {
+    final private ArrList<T> arr;
+
+    public MaxHeap() {
+        arr = new ArrList<>();
+    }
+
+    public MaxHeap(MaxHeap<T> heap) {
+        this.arr = new ArrList<>(heap.arr);
+    }
+
+    private int parent(int i) {
+        return (i - 1) / 2;
+    }
+
+    private int leftChild(int i) {
+        return 2 * i + 1;
+    }
+
+    private int rightChild(int i) {
+        return 2 * i + 2;
+    }
+
+    private void swap(int i, int j) {
+        T tmp = arr.get(i);
+        arr.set(i, arr.get(j));
+        arr.set(j, tmp);
+    }
+
+    public void heapify(int i) {
+        int largest = i;
+        int left = leftChild(i);
+        int right = rightChild(i);
+
+        if (left < arr.size() && arr.get(left).compareTo(arr.get(largest)) > 0) {
+            largest = left;
+        }
+
+        if (right < arr.size() && arr.get(right).compareTo(arr.get(largest)) > 0) {
+            largest = right;
+        }
+
+        if (largest != i) {
+            swap(i, largest);
+            heapify(largest);
+        }
+    }
+
+    public void insert(T x) {
+        arr.add(x);
+        int currentIndex = arr.size() - 1;
+        while (currentIndex > 0 && arr.get(currentIndex).compareTo(arr.get(parent(currentIndex))) > 0) {
+            swap(currentIndex, parent(currentIndex));
+            currentIndex = parent(currentIndex);
+        }
+    }
+
+    public boolean isEmpty() {
+        return arr.isEmpty();
+    }
+
+    public void rebuild() {
+        for (int i = parent(arr.size() - 1); i >= 0; i--) {
+            heapify(i);
+        }
+    }
+
+    public T pop() {
+        if (arr.isEmpty()) {
+            throw new RuntimeException("Heap is empty");
+        }
+
+        T max = arr.get(0);
+        T lastElement = arr.removeLast();
+
+        if (!arr.isEmpty()) {
+            arr.set(0, lastElement);
+
+            int currentIndex = 0;
+            while (true) {
+                int left = leftChild(currentIndex);
+                int right = rightChild(currentIndex);
+
+                int largest = currentIndex;
+
+                if (left < arr.size() && arr.get(left).compareTo(arr.get(largest)) > 0) {
+                    largest = left;
+                }
+
+                if (right < arr.size() && arr.get(right).compareTo(arr.get(largest)) > 0) {
+                    largest = right;
+                }
+
+                if (largest == currentIndex) {
+                    break;
+                }
+
+                swap(currentIndex, largest);
+
+                currentIndex = largest;
+            }
+        }
+
+        return max;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < arr.size(); i++) {
+            sb.append(arr.get(i)).append(" ");
+        }
+        return sb.toString();
+    }
+}
+
+class LinkedList<T> {
+    class Node {
+        T value;
+        Node next;
+
+        Node(T value) {
+            this.value = value;
+        }
+    }
+
+    Node root;
+
+    public void add(T value) {
+        Node node = new Node(value);
+        node.next = root;
+        root = node;
+    }
+}
+
+class ArrList<T> {
+    private T[] array;
+    private int size;
+
+    @SuppressWarnings("unchecked")
+    public ArrList() {
+        array = (T[]) new Object[64];
+        size = 0;
+    }
+
+    @SuppressWarnings("unchecked")
+    public ArrList(ArrList<T> list) {
+        this.size = list.size;
+        this.array = (T[]) new Object[list.array.length];
+        System.arraycopy(list.array, 0, this.array, 0, list.size);
+    }
+
+    private boolean isFull() {
+        return size == array.length;
+    }
+
+    private void resize() {
+        @SuppressWarnings("unchecked")
+        T[] tmp = (T[]) new Object[array.length * 2];
+        System.arraycopy(array, 0, tmp, 0, size);
+        array = tmp;
+    }
+
+    public T get(int i) {
+        return array[i];
+    }
+
+    public void add(T t) {
+        if (isFull()) {
+            resize();
+        }
+        array[size++] = t;
+    }
+
+    public void set(int i, T t) {
+        array[i] = t;
+    }
+
+    public T removeLast() {
+        T tmp = array[--size];
+        array[size] = null;
+        return tmp;
+    }
+
+    public int size() {
+        return size;
+    }
+
+    public boolean isEmpty() {
+        return size == 0;
+    }
+
+    @Override
+    public String toString() {
+        StringBuilder sb = new StringBuilder();
+        for (int i = 0; i < size; i++) {
+            sb.append(array[i]).append(" ");
+        }
+        return sb.toString();
+    }
+}

naloga4/src/Naloga4.java

@@ -0,0 +1,53 @@
+import java.util.*;
+
+public class Naloga4 {
+    public static void main(String[] args) {
+        System.gc();
+        Graf g = GrafGenerator.generateBarabasiAlbertGraph(40_000, 10);
+        System.gc();
+        long startTime = System.currentTimeMillis();
+        g.pozresni();
+        long endTime = System.currentTimeMillis();
+        System.out.println(endTime - startTime);
+    }
+}
+
+class GrafGenerator {
+    public static Graf generateBarabasiAlbertGraph(int n, int m) {
+        if (m < 1 || m >= n) {
+            throw new IllegalArgumentException("Neveljaven 'm'");
+        }
+
+        Graf graph = new Graf(n);
+        List<Integer> nodePool = new ArrayList<>();
+
+        // Zacnem z polnim grafom velikosti m
+        for (int i = 0; i < m; i++) {
+            for (int j = i + 1; j < m; j++) {
+                graph.povezi(i, j);
+                nodePool.add(i);
+                nodePool.add(j);
+            }
+        }
+
+        Random rand = new Random(5);
+
+        // Povezi preostala vozlisca
+        for (int newNode = m; newNode < n; newNode++) {
+            Set<Integer> targets = new HashSet<>();
+
+            while (targets.size() < m) {
+                int selected = nodePool.get(rand.nextInt(nodePool.size()));
+                targets.add(selected);
+            }
+
+            for (int target : targets) {
+                graph.povezi(newNode, target);
+                nodePool.add(newNode);
+                nodePool.add(target);
+            }
+        }
+
+        return graph;
+    }
+}