Constructing a data structure supporting prioritized key lookup

so this is more or less a shot in the dark as I am feeling stuck. Maybe some of you have an idea which helps.

Here is the problem description (pseudo formal):

I want to have a structure $$T = \{ \hat{x_1}, \hat{x_2}, … \}$$ with $$\hat{x_i} = (p_i, k_i, v_{k_i})$$.

$$p_i \in \mathbb{N}$$ can be interpreted as an associated priority. They can be considered unqiue.

$$k_i \in \mathcal{K}$$ a key index, $$d := |\mathcal{K}|$$ is not required to be negligibly small, though generally $$d \lt\lt |T|$$

$$v_{k_i} \in \mathcal{V}^{(k_i)}$$ a partial key over some universe associated with the given key index. As a little pace killer, this key may not be hashable. The only requirement is totally ordered.

Considering an array $$y = [v_i], i \in \mathcal{K}$$, the structure should be capable of supporting the following operations efficiently:

$$lookup(T, y) \rightarrow \underset{x_i \in T : y[k_i] = v_{k_i}}{arg max}( p_i )$$, i.e. the node $$\hat{x_j}$$ with a partial key matching and the highest associated priority.

$$succ(T, y) \rightarrow lookup(T \backslash \{\hat{x_j}\}, y)$$, i.e. the successor (in terms of priority) of a node $$\hat{x_j}$$ matching $$y$$

Ultimately I would also like efficient insertion and deletion (by priority).

(For insertion: The selection of $$k_i$$ for each node is another point of research and can by chosen at the time of insertion. It is essentially possible that this key index is subject to change if it helps the overall structure. But it is also not required that all key indices in $$\mathcal{K}$$ are supported for each node, i.e. one might need to insert a node which is only queryable by a single $$k_i$$.)

The key indices are somewhat causing a headache for me. My research so far includes standard priority search trees and dynamic variations thereof. I also found this very interesting, though very theoretical, paper which takes care of the increased dimensionality (kind of) caused by the d-dimensional keys.

I know that I can construct d-dimensional binary search trees with a query complexity of $$O(d + n log(n))$$. These should definitely yield a gain though I am not capable of mapping the priority problem to it (Ref).

But I guess the complexity can be reduced even further if we consider that fact, that each node is only storing partial keys anyway.

My approach so far is somewhat naive as it simply creates a hash map for each key index in $$\mathcal{K}$$ and queries each hash map upon lookup. It then aggregates all the results and sorts them by priority. This works fine for hashable keys but a fallback structure has to be used whenever they are not (I am using binary search trees).

Constructing an error avoiding monitor

When going through a paper, https://link.springer.com/chapter/10.1007/978-3-319-40648-0_6. I have not been able to get the idea of the algorithm to construct an error avoiding monitor mentioned on page 9 and how to apply the same to examples. I would also like to understand the method of the synchronous product of two automata, each dealing with separate alphabets mentioned in the paper. I will be grateful for any helpful advice or resources.

Constructing a PDA which acceptsL {${a^i b^j c^k}$| $i,j,k≥0$ and $i=j$ or $i=k$}

I have to construct a PDA which accepts the L {$${a^i b^j c^k}$$| $$i,j,k≥0$$ and $$i=j$$ or $$i=k$$}

I cannot quite graph how to handle the ‘or’

To make it easier for myself, I constructed strings where $$i=j$$

{$${c,abc,abcc,aaabbbc,ab..}$$}

and for $$i=k$$

{$${b,ac,abc,aabcc, ..}$$}

How do I approach this correctly? This is the first time I am trying to construct a PDA, so any hints to the right direction would be appreciated. Thank you 🙂

Constructing an NFA for a language defined over Σ = {0, 1}

The language is defined as L = {0n10m10q | n,m,q,∈ N, q ≡ nm (mod 5)}. Can someone help me get started on this question? I don’t know what part of the question I should do first. I have made an automaton that keeps track of mod 5, what next?

Constructing Generalised Suffix Tree from a large set of strings

Is there a published method to construct a generalised suffix tree from a large set of strings (~ 500 000) without the need of concatenating them?

I would like to use the resulting suffix tree for a pattern search problem.

Constructing preorder traversal from postorder of a Binary Search Tree in O(n)

We are given postorder traversal of a Binary “SEARCH” Tree (in an array) and we want to find (print) its preorder traversal.

A very naive solution is to check from end until we find element less than root so we can find left and right subtree and call the function on them. This is $$O(n^2)$$. Another way is to generate the BST from its postorder and then generate the preorder from postorder. it is $$O ( n log n )$$ because for generating tree we need $$O(n log n)$$ and for preorder traversal we need $$O(n)$$ and $$O(n + n log n ) = O(n logn)$$.

I think we can do it better in $$O(n)$$ because there is a lot known about the nature of the binary search tree and this extra information must help somehow. but I don’t know how to use information we know about BST and implement this problem in $$O(n)$$.

Constructing a PDA to accept the language L={a^i b^j c^k where i,j,k>0 and i

can anybody help me out with this ? if i try to compare a’s with b’s to check if j>=i then i wont be able to compare the same number of b’s with the number of c’s that is to check if j<=2k

Pushdown Automata – constructing a PDA to recognise a language with at least as many as as bs

I am trying to construct a 3-state PDA to recognise (I need to create a transition diagram for this question)

W = {w ∈ {a, b}^* | w contains at least as many as as bs} 

My thought process so far has been this:

 1. Start off in q0 (q0 being an accept state)  2. add a $to the start of the stack (so you can see when the stack is empty), then transition to q1 (not an accept state). 3. If you receive an a: - if there is an a at the top of the stack, push the a on. - if there is a b at the top of the stack, pop the b. - if there is nothing on the top of the stack, push the a on. 4. If you receive a b: - if there is an a at the top of the stack, pop the a. - if there is a b at the top of the stack, push the b on. - if there is nothing on the top of the stack push the b on. 5. Once there is no more input: - if there is a$   at the top of the stack, transition to q3 (q3 being an accept state) - this means there was an equal number of as and bs   - if there is an a at the top of the stack, transition to q3 (q3 being an accept state) - this means there was more as than bs   if there is a b at the top of the stack, it means there was more bs than as, and thus we stay in q2, which is not an accept state. 

(Sorry if this is hard to understand, I am not sure how to link those transition diagrams of the PDA’s I’ve seen in some posts, if someone can tell me how to create one and link it in the post, I can update the post to be more understandable if needed)

I have a few questions:

1. Is this approach correct?
2. Is the it correct to assume the machine is smart enough to know that if there isn’t a b at the top of the stack, and I receive an a, it will push that a onto the stack (something like (q1, a, ε) -> (q1, a) to cover both cases where there is an a on the top of the stack and also the case where the stack has nothing in it))
3. Do I need to push a $at the start from q0 to q1 in the transition diagram (I’ve seen this to be the case for all PDAs on my lecture slide – which makes me think is it necessary to include if all machines need to do this – why is it not just implied?) 4. I am ok to have 2 different scenarios to go to q2 right? Or would I be better doing something in q1, where if I have reached the end of my input queue, keep popping off as on the top of the stack until I reach the$ , then transition to q2?

Sorry if anything is unclear – I am not super familiar with PDAs and the way to describe things – please let me know if I need to clarify anything.

Constructing a directed graph for O(1) queries

I need help to design a data structure for a directed graph with the following properties:

1. Initialization should be done in O(1) time.
2. AddVertex(id1,id2,…idK) – Add a new vertex to the graph. The new vertex is added with id=N+1 where N is the number of existing vertices. id1…idK are the neighbors of the new vertex, such that there is an outgoing edge from the new added vertex to each of the vertices id1 .. idK. This should be done in O(1) time.
3. GetNumberOfNeighbors(id) – Return the number of outgoing edges for a vertex with a given id (id is in 1..N). This should be done in O(1) time. All O(1) times are for worse case.

Thanks allot

Constructing elliptic curves defined over $\mathbb{Q}$ with fixed complex multiplication

I have the following problem: we know that for a field $$\kappa$$ of characteristic $$0$$ usually an elliptic curve $$E$$ defined over $$\kappa$$ is such that $$End(E)\cong \mathbb{Z}$$. This means that one cannot hope to find an elliptic curve with complex multiplication choosing it “randomly”.

Suppose that i want to produce and elliptic curve over $$\mathbb{Q}$$ whose $$End(E)$$ is and order in $$\mathbb{Q}(\sqrt{-D})$$: what are the methods currently known to do it? Is it possible to write explicitly the isogeny corresponding to $$\sqrt{-D}$$? (If it is in $$End(E)$$ and $$D$$ is not so large).

Thank you for your time.