arXiv subjects

Andrej Brodnik

Publications and source records attributed to Andrej Brodnik.

14 recordsLinked to original sources

arXiv2025

Improving Online Bin Covering with Little Advice

The online bin covering problem is: given an input sequence of items find a placement of the items in the maximum number of bins such that the sum of the items' sizes in each bin is at least~1. Boyar~{\em et~al}.\@~\cite{boyar2021} present a strategy that with $O(\log \log n)$ bits of advice, where $n$ is the length of the input sequence, achieves a competitive ratio of $8/15\approx0.5333\ldots$. We show that with a strengthened analysis and some minor improvements, the same strategy achieves the significantly improved competitive ratio of~$135/242\approx0.5578\ldots$, still using $O(\log \log n)$ bits of advice.

cs.DS↗

arXiv2023

Online Bin Covering with Exact Parameter Advice

We show an asymptotic 2/3-competitive strategy for the bin covering problem using O(b+log n) bits of advice, where b is the number of bits used to encode a rational value and n is the length of the input sequence.

cs.DS↗

arXiv2022

Zero-Knowledge Authentication

In the thesis we focus on designing an authentication system to authenticate users over a network with a username and a password. The system uses the zero-knowledge proof (ZKP) system as a password verification mechanism. The ZKP protocol used is based on the quadratic residuosity problem. The authentication system is defined as a method in the extensible authentication protocol (EAP). Using a ZKP system yields interesting security properties that make the system favourable to be used over insecure networks.

cs.CR↗

arXiv2021

Programming for All: Understanding the Nature of Programs

Computer programs are part of our daily life, we use them, we provide them with data, they support our decisions, they help us remember, they control machines, etc. Programs are made by people, but in most cases we are not their authors, so we have to decide if we can trust them. Programs enable computers and computer-controlled machines to behave in a large variety of ways. They bring the intrinsic power of computers to life. Programs have a variety of properties that all citizens must be aware of. Due to the intangible nature of programs, most of these properties are very unusual, but important to understand the digital world. In this position paper, we describe the Nature of Programs in the form of knowledge statements, accompanied by examples from everyday life to clarify their meaning. Everything is formulated in an easily understandable manner and avoids obscure technical language. We suggest that these knowledge statements must be imparted to all teachers and school students. A great way to learn and experience the nature of programs is to develop programs yourself.

cs.CY↗

arXiv2020

The simultaneous conjugacy problem in the symmetric group

The transitive simultaneous conjugacy problem asks whether there exists a permutation $τ\in S_n$ such that $b_j = τ^{-1} a_j τ$ holds for all $j = 1,2, \ldots, d$, where $a_1, a_2, \ldots, a_d$ and $b_1, b_2, \ldots, b_d$ are given sequences of $d$ permutations in $S_n$, each of which generates a transitive subgroup of $S_n$. As from mid 70' it has been known that the problem can be solved in $O(dn^2)$ time. An algorithm with running time $O(dn \log(dn))$, proposed in late 80', does not work correctly on all input data. In this paper we solve the transitive simultaneous conjugacy problem in $O(n^2 \log d / \log n + dn\log n)$ time and $O(n^{3/ 2} + dn)$ space. Experimental evaluation on random instances shows that the expected running time of our algorithm is considerably better, perhaps even nearly linear in $n$ at given $d$.

cs.DM↗

arXiv2020

A subquadratic algorithm for the simultaneous conjugacy problem

The $d$-Simultaneous Conjugacy problem in the symmetric group $S_n$ asks whether there exists a permutation $τ\in S_n$ such that $b_j = τ^{-1}a_j τ$ holds for all $j = 1,2,\ldots, d$, where $a_1, a_2,\ldots , a_d$ and $b_1, b_2,\ldots , b_d$ are given sequences of permutations in $S_n$. The time complexity of existing algorithms for solving the problem is $O(dn^2)$. We show that for a given positive integer $d$ the $d$-Simultaneous Conjugacy problem in $S_n$ can be solved in $o(n^2)$ time.

cs.DS↗

arXiv2018

Sliding Suffix Tree using LCA

We consider a sliding window $W$ over a stream of characters from some alphabet of constant size. The user wants to perform deterministic substring matching on the current sliding window content and obtain positions of the matches. We present an indexed version of the sliding window using the suffix tree, the link tree and the lowest common ancestor. The data structure of size $Θ(|W|)$ has optimal time queries $Θ(m+occ)$ and amortized constant time updates, where $m$ is the length of the query string and $occ$ is the number of its occurrences.

cs.DS↗

arXiv2016

Increasing the throughput of machine translation systems using clouds

The manuscript presents an experiment at implementation of a Machine Translation system in a MapReduce model. The empirical evaluation was done using fully implemented translation systems embedded into the MapReduce programming model. Two machine translation paradigms were studied: shallow transfer Rule Based Machine Translation and Statistical Machine Translation. The results show that the MapReduce model can be successfully used to increase the throughput of a machine translation system. Furthermore this method enhances the throughput of a machine translation system without decreasing the quality of the translation output. Thus, the present manuscript also represents a contribution to the seminal work in natural language processing, specifically Machine Translation. It first points toward the importance of the definition of the metric of throughput of translation system and, second, the applicability of the machine translation task to the MapReduce paradigm.

cs.CL↗

arXiv2016

ERA Revisited: Theoretical and Experimental Evaluation

Efficient construction of the suffix tree given an input text is an active area of research from the time it was first introduced. Both theoretical computer scientists and engineers tackled the problem. In this paper we focus on the fastest practical suffix tree construction algorithm to date, ERA. We first provide a theoretical analysis of the algorithm assuming the uniformly random text as an input and using the PEM model of computation with respect to the lower bounds. Secondly, we empirically confirm the theoretical results in different test scenarios exposing the critical terms. Thirdly, we discuss the fundamental characteristics of the input text where the fastest suffix tree construction algorithms in practice fail. This paper serves as a foundation for further research in the parallel text indexing area.

cs.DC↗

arXiv2015

Parallel Query in the Suffix Tree

Given the query string of length $m$, we explore a parallel query in a static suffix tree based data structure for $p \ll n$, where $p$ is the number of processors and $n$ is the length of the text. We present three results on CREW PRAM. The parallel query in the suffix trie requires $O(m + p)$ work, $O(m/p + \lg p)$ time and $O(n^2)$ space in the worst case. We extend the same technique to the suffix tree where we show it is, by design, inherently sequential in the worst case. Finally we perform the parallel query using an interleaved approach and achieve $O(m \lg p)$ work, $O(\frac{m}{p} \lg p)$ time and $O(n \lg p)$ space in the worst case.

cs.DS↗

arXiv2012

Speeding up shortest path algorithms

Given an arbitrary, non-negatively weighted, directed graph $G=(V,E)$ we present an algorithm that computes all pairs shortest paths in time $\mathcal{O}(m^* n + m \lg n + nT_ψ(m^*, n))$, where $m^*$ is the number of different edges contained in shortest paths and $T_ψ(m^*, n)$ is a running time of an algorithm to solve a single-source shortest path problem (SSSP). This is a substantial improvement over a trivial $n$ times application of $ψ$ that runs in $\mathcal{O}(nT_ψ(m,n))$. In our algorithm we use $ψ$ as a black box and hence any improvement on $ψ$ results also in improvement of our algorithm. Furthermore, a combination of our method, Johnson's reweighting technique and topological sorting results in an $\mathcal{O}(m^*n + m \lg n)$ all-pairs shortest path algorithm for arbitrarily-weighted directed acyclic graphs. In addition, we also point out a connection between the complexity of a certain sorting problem defined on shortest paths and SSSP.

cs.DS↗

arXiv2006

An O(1) Solution to the Prefix Sum Problem on a Specialized Memory Architecture

In this paper we study the Prefix Sum problem introduced by Fredman. We show that it is possible to perform both update and retrieval in O(1) time simultaneously under a memory model in which individual bits may be shared by several words. We also show that two variants (generalizations) of the problem can be solved optimally in $Θ(\lg N)$ time under the comparison based model of computation.

cs.DS↗

arXiv2003

Static Data Structure for Discrete Advance Bandwidth Reservations on the Internet

In this paper we present a discrete data structure for reservations of limited resources. A reservation is defined as a tuple consisting of the time interval of when the resource should be reserved, $I_R$, and the amount of the resource that is reserved, $B_R$, formally $R=\{I_R,B_R\}$. The data structure is similar to a segment tree. The maximum spanning interval of the data structure is fixed and defined in advance. The granularity and thereby the size of the intervals of the leaves is also defined in advance. The data structure is built only once. Neither nodes nor leaves are ever inserted, deleted or moved. Hence, the running time of the operations does not depend on the number of reservations previously made. The running time does not depend on the size of the interval of the reservation either. Let $n$ be the number of leaves in the data structure. In the worst case, the number of touched (i.e. traversed) nodes is in any operation $O(\log n)$, hence the running time of any operation is also $O(\log n)$.

cs.DS↗

arXiv2003

Data Structure for a Time-Based Bandwidth Reservations Problem

We discuss a problem of handling resource reservations. The resource can be reserved for some time, it can be freed or it can be queried what is the largest amount of reserved resource during a time interval. We show that the problem has a lower bound of $Ω(\log n)$ per operation on average and we give a matching upper bound algorithm. Our solution also solves a dynamic version of the related problems of a prefix sum and a partial sum.

cs.DS↗